A posix clock/timer interface to the RTC
Subsystems (4)
cover A posix clock/timer interface to the RTC
From: John Stultz <[email protected]>
This patchset allows the RTC to be managed via the posix_clocks/timers interface. This allows applications to program timer events that will wake the system from suspend state. If the system is not suspended, the timers fire like normal posix timers.
Currently, if an application wants to trigger a RTC alarm to wake up from suspend, they must use the sysfs wakealarm interface or the rtc chardev RTC_WKALM_SET ioctl. The limitation with this interface is that it is fairly hardware oriented, so multiple applications cannot set an RTC alarm without overwriting any previous alarms set by other applications.
The in-kernel posix interface allows for the kernel to manage a list of timers that control when the alarm is fired, so applications do not need to coordinate access to the alarm hardware.
My earlier proof-of-concept hack/patch for this work (see
http://lwn.net/Articles/405986/ ) did not get much review from the RTC folks, so I've carried on reworking a number of layers of code in order to make this functionality something that could possibly be upstreamed in the future.
The patches are still fairly rough, but together they do function, so while there is still work to be done, I wanted to send this out again so folks had an idea of the scope of the work and could make suggestions as to where I've gone wrong. :)
So please let me know what you think.
thanks
-john
John Stultz (5):
[RFC] Introduce timerlist infrastructure.
[RFC] hrtimers: Convert hrtimers to use timerlist infrastructure [RFC] RTC: Rework RTC code to use timerlist for events [RFC] RTC: Remove UIE emulation
[RFC] RTC: Add posix clock/timer interface
Richard Cochran (1):
[RFC] posix clocks: dynamic clock ids.
drivers/rtc/Makefile | 2 +- drivers/rtc/class.c | 23 ++ drivers/rtc/interface.c | 453 +++++++++++++++++++++--------------------- drivers/rtc/posix.c | 274 +++++++++++++++++++++++++ drivers/rtc/rtc-dev.c | 104 ---------- drivers/rtc/rtc-lib.c | 26 +++ drivers/rtc/rtc-sysfs.c | 10 + include/linux/hrtimer.h | 32 ++-- include/linux/posix-timers.h | 9 +- include/linux/rtc.h | 49 +++-- include/linux/time.h | 2 + include/linux/timerlist.h | 37 ++++ kernel/hrtimer.c | 86 +++----- kernel/posix-timers.c | 41 +++- kernel/time/timer_list.c | 8 +- lib/Makefile | 2 +- lib/timerlist.c | 115 +++++++++++ 17 files changed, 843 insertions(+), 430 deletions(-) create mode 100644 drivers/rtc/posix.c create mode 100644 include/linux/timerlist.h create mode 100644 lib/timerlist.c
RFC PATCH 1/6 posix clocks: dynamic clock ids.
From: Richard Cochran <[email protected]>
This patch augments the POSIX clock code to offer a dynamic clock creation method. Instead of registering a hard coded clock ID, modules may call create_posix_clock(), which returns a new clock ID.
This patch still has un-addressed lifetime issues pointed out by Alan Cox. More work is needed here, but for now this provides the functionality needed for the following patches.
--- include/linux/posix-timers.h | 7 ++++++- include/linux/time.h | 2 ++ kernel/posix-timers.c | 41 ++++++++++++++++++++++++++++++++++------- 3 files changed, 42 insertions(+), 8 deletions(-)
include/linux/posix-timers.h +6 -1
@@ -67,6 +67,7 @@ struct k_itimer { };struct k_clock { +clockid_t id;int res;/* in nanoseconds */ int (*clock_getres) (const clockid_t which_clock,struct timespec *tp);int (*clock_set) (const clockid_t which_clock,struct timespec * tp);
@@ -84,7 +85,11 @@ struct k_clock { struct itimerspec * cur_setting); }; -void register_posix_clock (const clockid_t clock_id,struct k_clock *new_clock); +/* Regsiter a posix clock with a "well known" clock id. */ +int register_posix_clock (const clockid_t id,struct k_clock *clock); + +/* Create a new posix clock with a dynamic clock id. */ +clockid_t create_posix_clock (struct k_clock *clock);/* error handlers for timer_create, nanosleep and settime */ int do_posix_clock_nonanosleep(const clockid_t, int flags, struct timespec *,
include/linux/time.h +2 -0
@@ -299,6 +299,8 @@ struct itimerval {#define CLOCKS_MASK (CLOCK_REALTIME | CLOCK_MONOTONIC)#define CLOCKS_MONO CLOCK_MONOTONIC +#define CLOCK_INVALID -1 +/* * The various flags for setting POSIX.1b interval timers: */
kernel/posix-timers.c +34 -7
58 lines not on this page · raw message
Signature · 1 line
1.6.0.4
RFC PATCH 2/6 Introduce timerlist infrastructure.
The timerlist infrastructure is a thin layer over the rbtree code that implements a simple list of timers sorted by an expires value, and a getnext function that provides a pointer to the earliest timer.
This infrastructure allows drivers and other kernel infrastructure to easily implement timers without duplicating code.
Suggestions or feedback would be appreciated.
--- include/linux/timerlist.h | 37 ++++++++++++++ lib/Makefile | 2 +- lib/timerlist.c | 115 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 153 insertions(+), 1 deletions(-) create mode 100644 include/linux/timerlist.h create mode 100644 lib/timerlist.c
include/linux/timerlist.h new file +37 -0
@@ -0,0 +1,37 @@ +#ifndef _LINUX_TIMERLIST_H +#define _LINUX_TIMERLIST_H + +#include <linux/rbtree.h> +#include <linux/ktime.h> + + +struct timerlist_node { +struct rb_node node; +ktime_t expires; +}; + +struct timerlist_head { +struct rb_root head; +struct timerlist_node *next; +}; + + +extern void timerlist_add (struct timerlist_head *head, +struct timerlist_node *node); +extern void timerlist_del (struct timerlist_head *head, +struct timerlist_node *node); +extern struct timerlist_node *timerlist_getnext (struct timerlist_head *head); +extern struct timerlist_node *timerlist_iterate_next ( +struct timerlist_node *node); + +static inline void timerlist_init (struct timerlist_node *node) +{ +RB_CLEAR_NODE (&node->node); +} + +static inline void timerlist_init_head (struct timerlist_head *head) +{ + head->head =RB_ROOT ; + head->next =NULL ; +} +#endif /* _LINUX_TIMERLIST_H */
lib/Makefile +1 -1
@@ -8,7 +8,7 @@ KBUILD_CFLAGS = $(subst -pg,,$(ORIG_CFLAGS)) endif lib-y := ctype.o string.o vsprintf.o cmdline.o \ - rbtree.o radix-tree.o dump_stack.o \ + rbtree.o radix-tree.o dump_stack.o timerlist.o\ idr.o int_sqrt.o extable.o prio_tree.o \ sha1.o irq_regs.o reciprocal_div.o argv_split.o \ proportions.o prio_heap.o ratelimit.o show_mem.o \
lib/timerlist.c new file +115 -0
115 lines not on this page · raw message
Signature · 1 line
1.6.0.4
RFC PATCH 3/6 hrtimers: Convert hrtimers to use timerlist infrastructure
Converts the hrtimer code to use the timerlist infrastructure
Survived some light testing, but there may still be bugs.
--- include/linux/hrtimer.h | 32 ++++++++--------- kernel/hrtimer.c | 86 ++++++++++++++++------------------------------ kernel/time/timer_list.c | 8 ++-- 3 files changed, 49 insertions(+), 77 deletions(-)
include/linux/hrtimer.h +15 -17
@@ -22,7 +22,7 @@#include <linux/wait.h> #include <linux/percpu.h> #include <linux/timer.h> - +#include <linux/timerlist.h> struct hrtimer_clock_base ;struct hrtimer_cpu_base ;
@@ -79,8 +79,8 @@ enum hrtimer_restart {/** * struct hrtimer - the basic hrtimer structure -* @node: red black tree node for time ordered insertion -* @_expires: the absolute expiry time in the hrtimers internal +* @node: timerlist node, which also manages node.expires, +* the absolute expiry time in the hrtimers internal * representation. The time is related to the clock on * which the timer is based. Is setup by adding * slack to the _softexpires value. For non range timers
@@ -101,8 +101,7 @@ enum hrtimer_restart {* The hrtimer structure must be initialized by hrtimer_init() */ struct hrtimer { -struct rb_node node; -ktime_t _expires; +struct timerlist_node node;ktime_t _softexpires;enum hrtimer_restart (*function)(struct hrtimer *);struct hrtimer_clock_base *base;
@@ -141,8 +140,7 @@ struct hrtimer_sleeper {struct hrtimer_clock_base {struct hrtimer_cpu_base *cpu_base;clockid_t index; -struct rb_root active; -struct rb_node *first; +struct timerlist_head active;ktime_t resolution;ktime_t (*get_time)(void );ktime_t softirq_time;
@@ -184,43 +182,43 @@ struct hrtimer_cpu_base {static inline void hrtimer_set_expires (struct hrtimer *timer,ktime_t time) { - timer->_expires = time; + timer->node.expires = time; timer->_softexpires = time; }static inline void hrtimer_set_expires_range (struct hrtimer *timer,ktime_t time,ktime_t delta) { timer->_softexpires = time; - timer->_expires =ktime_add_safe (time, delta); + timer->node.expires =ktime_add_safe (time, delta); }static inline void hrtimer_set_expires_range_ns (struct hrtimer *timer,ktime_t time,unsigned long delta) { timer->_softexpires = time; - timer->_expires =ktime_add_safe (time,ns_to_ktime (delta)); + timer->node.expires =ktime_add_safe (time,ns_to_ktime (delta)); }static inline void hrtimer_set_expires_tv64 (struct hrtimer *timer,s64 tv64) { - timer->_expires.tv64 = tv64; + timer->node.expires.tv64 = tv64; timer->_softexpires.tv64 = tv64; }static inline void hrtimer_add_expires (struct hrtimer *timer,ktime_t time) { - timer->_expires =ktime_add_safe (timer->_expires, time); + timer->node.expires =ktime_add_safe (timer->node.expires, time); timer->_softexpires =ktime_add_safe (timer->_softexpires, time); }static inline void hrtimer_add_expires_ns (struct hrtimer *timer,u64 ns) { - timer->_expires =ktime_add_ns (timer->_expires, ns); + timer->node.expires =ktime_add_ns (timer->node.expires, ns); timer->_softexpires =ktime_add_ns (timer->_softexpires, ns); }static inline ktime_t hrtimer_get_expires (const struct hrtimer *timer) { -return timer->_expires; +return timer->node.expires; }static inline ktime_t hrtimer_get_softexpires (const struct hrtimer *timer)
@@ -230,7 +228,7 @@ static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)static inline s64 hrtimer_get_expires_tv64 (const struct hrtimer *timer) { -return timer->_expires.tv64; +return timer->node.expires.tv64; }static inline s64 hrtimer_get_softexpires_tv64 (const struct hrtimer *timer) {
@@ -239,12 +237,12 @@ static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)static inline s64 hrtimer_get_expires_ns (const struct hrtimer *timer) { -return ktime_to_ns (timer->_expires); +return ktime_to_ns (timer->node.expires); }static inline ktime_t hrtimer_expires_remaining (const struct hrtimer *timer) { -return ktime_sub (timer->_expires, timer->base->get_time ()); +return ktime_sub (timer->node.expires, timer->base->get_time ()); }#ifdef CONFIG_HIGH_RES_TIMERS
kernel/hrtimer.c +30 -56
182 lines not on this page · raw message
kernel/time/timer_list.c +4 -4
@@ -79,26 +79,26 @@ print_active_timers(struct seq_file *m, struct hrtimer_clock_base *base, {struct hrtimer *timer, tmp;unsigned long next =0 , i; -struct rb_node *curr; +struct timerlist_node *curr;unsigned long flags; next_one: i =0 ;raw_spin_lock_irqsave (&base->cpu_base->lock, flags); - curr = base->first; + curr =timerlist_getnext (&base->active);/* * Crude but we have to do this O(N*N) thing, because * we have to unlock the base when printing: */ while (curr && i < next) { - curr =rb_next (curr); + curr =timerlist_iterate_next (curr); i++; }if (curr) { - timer = rb_entry(curr, struct hrtimer, node); + timer = container_of(curr, struct hrtimer, node); tmp = *timer;raw_spin_unlock_irqrestore (&base->cpu_base->lock, flags);
Signature · 1 line
1.6.0.4
RFC PATCH 4/6 RTC: Rework RTC code to use timerlist for events
This patch reworks a large portion of the generic RTC code to in-effect virtualize the rtc interrupt code.
The current RTC interface is very much a raw hardware interface. Via the proc, /dev/, or sysfs interfaces, applications can set the hardware to trigger interrupts in one of three modes:
AIE: Alarm interrupt
UIE: Update interrupt (ie: once per second)
PIE: Periodic interrupt (sub-second irqs)
The problem with this interface is that it limits the RTC hardware so it can only be used by one application at a time.
The purpose of this patch is to extend the RTC code so that we can multiplex multiple applications event needs onto a single RTC device. This is done by utilizing the timerlist infrastructure to manage a list of events, which cause the RTC hardware to be programmed to fire an interrupt for the next event in the list.
In order to preserve the functionality of the existing proc,/dev/ and sysfs interfaces, we emulate the different interrupt modes as follows:
AIE: We create a rtc_timer dedicated to AIE mode interrupts. There is only one per device, so we don't change existing interface semantics.
UIE: Again, a dedicated rtc_timer, set for periodic mode, is used to emulate UIE interrupts. Again, only one per device.
PIE: Since PIE mode interrupts fire faster then the RTC's clock read granularity, we emulate PIE mode interrupts using a hrtimer. Again, one per device.
With this patch, the rtctest.c application in Documentation/rtc.txt passes fine on x86 hardware. However, there may very well still be bugs, so greatly I'd appreciate any feedback or testing!
--- drivers/rtc/class.c | 21 +++ drivers/rtc/interface.c | 453 ++++++++++++++++++++++++----------------------- drivers/rtc/rtc-lib.c | 26 +++ include/linux/rtc.h | 38 ++++- 4 files changed, 309 insertions(+), 229 deletions(-)
drivers/rtc/class.c +21 -0
@@ -16,6 +16,7 @@#include <linux/kdev_t.h> #include <linux/idr.h> #include <linux/slab.h> +#include <linux/workqueue.h> #include "rtc-core.h"
@@ -152,6 +153,26 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,spin_lock_init (&rtc->irq_task_lock);init_waitqueue_head (&rtc->irq_queue); +/* Init timerlist */ +timerlist_init_head (&rtc->timerlist); +INIT_WORK (&rtc->irqwork, rtc_irq_do_work); +/* Init alarm timer */ +timerlist_init (&rtc->alarm_timer.node); + rtc->alarm_timer.enabled =0 ; + rtc->alarm_timer.task.func = rtc_alarm_update_irq; + rtc->alarm_timer.task.private_data = (void *)rtc; + rtc->alarm_timer.period =ktime_set (0 ,0 ); +/* Init uie timer */ +timerlist_init (&rtc->uie_rtctimer.node); + rtc->uie_rtctimer.enabled =0 ; + rtc->uie_rtctimer.task.func = rtc_alarm_update_irq; + rtc->uie_rtctimer.task.private_data = (void *)rtc; + rtc->uie_rtctimer.period =ktime_set (1 ,0 ); +/* Init pie timer */ +hrtimer_init (&rtc->pie_timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); + rtc->pie_timer.function = rtc_pie_update_irq; + rtc->pie_enabled =0 ; +strlcpy (rtc->name, name,RTC_DEVICE_NAME_SIZE );dev_set_name (&rtc->dev,"rtc%d" , id);
drivers/rtc/interface.c +229 -224
556 lines not on this page · raw message
drivers/rtc/rtc-lib.c +26 -0
@@ -117,4 +117,30 @@ int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time) }EXPORT_SYMBOL (rtc_tm_to_time); +/* +* Convert rtc_time to ktime +*/ +ktime_t rtc_tm_to_ktime (struct rtc_time tm) +{ +time_t time; +rtc_tm_to_time (&tm, &time); +return ktime_set (time,0 ); +} + +/* +* Convert ktime to rtc_time +*/ +struct rtc_time rtc_ktime_to_tm (ktime_t kt) +{ +struct timespec ts; +struct rtc_time ret; + + ts =ktime_to_timespec (kt); +/* Round up any ns */ +if (ts.tv_nsec) + ts.tv_sec++; +rtc_time_to_tm (ts.tv_sec, &ret); +return ret; +} +MODULE_LICENSE ("GPL" );
include/linux/rtc.h +33 -5
@@ -107,12 +107,17 @@ extern int rtc_year_days(unsigned int day, unsigned int month, unsigned int yearextern int rtc_valid_tm (struct rtc_time *tm);extern int rtc_tm_to_time (struct rtc_time *tm,unsigned long *time);extern void rtc_time_to_tm (unsigned long time,struct rtc_time *tm); +ktime_t rtc_tm_to_ktime (struct rtc_time tm); +struct rtc_time rtc_ktime_to_tm (ktime_t kt); +#include <linux/device.h> #include <linux/seq_file.h> #include <linux/cdev.h> #include <linux/poll.h> #include <linux/mutex.h> +#include <linux/timerlist.h> +#include <linux/workqueue.h> extern struct class *rtc_class;
@@ -151,7 +156,19 @@ struct rtc_class_ops { };#define RTC_DEVICE_NAME_SIZE 20 -struct rtc_task ; +typedef struct rtc_task { +void (*func)(void *private_data); +void *private_data; +}rtc_task_t ; + + +struct rtc_timer { +struct rtc_task task; +struct timerlist_node node; +ktime_t period; +int enabled; +}; +/* flags */ #define RTC_DEV_BUSY 0
@@ -179,6 +196,15 @@ struct rtc_devicespinlock_t irq_task_lock;int irq_freq;int max_user_freq; + +struct timerlist_head timerlist; +struct rtc_timer alarm_timer; +struct rtc_timer uie_rtctimer; +struct hrtimer pie_timer;/* sub second exp, so needs hrtimer */ +int pie_enabled; +struct work_struct irqwork; + +#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL struct work_struct uie_task;struct timer_list uie_timer;
@@ -224,15 +250,17 @@ extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled);extern int rtc_dev_update_irq_enable_emul (struct rtc_device *rtc,unsigned int enabled); -typedef struct rtc_task { -void (*func)(void *private_data); -void *private_data; -}rtc_task_t ; +void rtc_alarm_update_irq (void *private); +enum hrtimer_restart rtc_pie_update_irq (struct hrtimer *timer); +void rtc_irq_do_work (struct work_struct *work);int rtc_register (rtc_task_t *task);int rtc_unregister (rtc_task_t *task);int rtc_control (rtc_task_t *t,unsigned int cmd,unsigned long arg); +void rtctimer_enqueue (struct rtc_device *rtc,struct rtc_timer *timer); +void rtctimer_remove (struct rtc_device *rtc,struct rtc_timer *timer); +static inline bool is_leap_year (unsigned int year) {return (!(year %4 ) && (year %100 )) || !(year %400 );
Signature · 1 line
1.6.0.4
RFC PATCH 5/6 RTC: Remove UIE emulation
Since we provide UIE interrupts via a rtc_timer, the old emulation code can be removed.
Note: I assume this is ok, but there may be corner cases I'm missing.
--- drivers/rtc/rtc-dev.c | 104 ------------------------------------------------- include/linux/rtc.h | 12 ------ 2 files changed, 0 insertions(+), 116 deletions(-)
drivers/rtc/rtc-dev.c +0 -104
@@ -46,105 +46,6 @@ static int rtc_dev_open(struct inode *inode, struct file *file)return err; } -#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL -/* -* Routine to poll RTC seconds field for change as often as possible, -* after first RTC_UIE use timer to reduce polling -*/ -static void rtc_uie_task (struct work_struct *work) -{ -struct rtc_device *rtc = - container_of(work, struct rtc_device, uie_task); -struct rtc_time tm; -int num =0 ; -int err; - - err =rtc_read_time (rtc, &tm); - -spin_lock_irq (&rtc->irq_lock); -if (rtc->stop_uie_polling || err) { - rtc->uie_task_active =0 ; - }else if (rtc->oldsecs != tm.tm_sec) { - num = (tm.tm_sec +60 - rtc->oldsecs) %60 ; - rtc->oldsecs = tm.tm_sec; - rtc->uie_timer.expires = jiffies +HZ - (HZ /10 ); - rtc->uie_timer_active =1 ; - rtc->uie_task_active =0 ; -add_timer (&rtc->uie_timer); - }else if (schedule_work (&rtc->uie_task) ==0 ) { - rtc->uie_task_active =0 ; - } -spin_unlock_irq (&rtc->irq_lock); -if (num) -rtc_update_irq (rtc, num,RTC_UF |RTC_IRQF ); -} -static void rtc_uie_timer (unsigned long data) -{ -struct rtc_device *rtc = (struct rtc_device *)data; -unsigned long flags; - -spin_lock_irqsave (&rtc->irq_lock, flags); - rtc->uie_timer_active =0 ; - rtc->uie_task_active =1 ; -if ((schedule_work (&rtc->uie_task) ==0 )) - rtc->uie_task_active =0 ; -spin_unlock_irqrestore (&rtc->irq_lock, flags); -} - -static int clear_uie (struct rtc_device *rtc) -{ -spin_lock_irq (&rtc->irq_lock); -if (rtc->uie_irq_active) { - rtc->stop_uie_polling =1 ; -if (rtc->uie_timer_active) { -spin_unlock_irq (&rtc->irq_lock); -del_timer_sync (&rtc->uie_timer); -spin_lock_irq (&rtc->irq_lock); - rtc->uie_timer_active =0 ; - } -if (rtc->uie_task_active) { -spin_unlock_irq (&rtc->irq_lock); -flush_scheduled_work (); -spin_lock_irq (&rtc->irq_lock); - } - rtc->uie_irq_active =0 ; - } -spin_unlock_irq (&rtc->irq_lock); -return 0 ; -} - -static int set_uie (struct rtc_device *rtc) -{ -struct rtc_time tm; -int err; - - err =rtc_read_time (rtc, &tm); -if (err) -return err; -spin_lock_irq (&rtc->irq_lock); -if (!rtc->uie_irq_active) { - rtc->uie_irq_active =1 ; - rtc->stop_uie_polling =0 ; - rtc->oldsecs = tm.tm_sec; - rtc->uie_task_active =1 ; -if (schedule_work (&rtc->uie_task) ==0 ) - rtc->uie_task_active =0 ; - } - rtc->irq_data =0 ; -spin_unlock_irq (&rtc->irq_lock); -return 0 ; -} - -int rtc_dev_update_irq_enable_emul (struct rtc_device *rtc,unsigned int enabled) -{ -if (enabled) -return set_uie (rtc); -else -return clear_uie (rtc); -} -EXPORT_SYMBOL (rtc_dev_update_irq_enable_emul); - -#endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */ static ssize_t rtc_dev_read (struct file *file,char __user *buf,size_t count,loff_t *ppos)
@@ -493,11 +394,6 @@ void rtc_dev_prepare(struct rtc_device *rtc) rtc->dev.devt =MKDEV (MAJOR (rtc_devt), rtc->id); -#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL -INIT_WORK (&rtc->uie_task, rtc_uie_task); -setup_timer (&rtc->uie_timer, rtc_uie_timer, (unsigned long )rtc); -#endif -cdev_init (&rtc->char_dev, &rtc_dev_fops); rtc->char_dev.owner = rtc->owner; }
include/linux/rtc.h +0 -12
@@ -203,18 +203,6 @@ struct rtc_devicestruct hrtimer pie_timer;/* sub second exp, so needs hrtimer */ int pie_enabled;struct work_struct irqwork; - - -#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL -struct work_struct uie_task; -struct timer_list uie_timer; -/* Those fields are protected by rtc->irq_lock */ -unsigned int oldsecs; - unsigned int uie_irq_active:1; - unsigned int stop_uie_polling:1; - unsigned int uie_task_active:1; - unsigned int uie_timer_active:1; -#endif };#define to_rtc_device (d) container_of(d, struct rtc_device, dev)
Signature · 1 line
1.6.0.4
RFC PATCH 6/6 RTC: Add posix clock/timer interface
This patch provides an initial implementation of the posix clock/timer interface to the RTC. Since the current /dev, proc, and sysfs interfaces don't queue events, two applications trying to set a wakeup events in the future might race, causing events to be missed. The posix interface allows multiple applications to be able to set timers against a single RTC device, letting the kernel manage the multiplexing.
One example use would be a backup job that is done at night on a desktop system that suspends after 15 minutes of idle time. A cron-like job manager could set a posix timer against the RTC to ensure the system woke from suspend in order to run the backup.
However, the system might also run a DVR application to record a favorite show. That application could also use the posix interface to set a timer against the RTC without having to worry if it had overwritten the timer set for the backup job.
Since there can be multiple RTCs on a system, we utilize the dynamic posix clock registration code, and export the clockid via /sys/class/rtc/rtcN/posix_clockid.
--- drivers/rtc/Makefile | 2 +- drivers/rtc/class.c | 2 + drivers/rtc/posix.c | 274 ++++++++++++++++++++++++++++++++++++++++++ drivers/rtc/rtc-sysfs.c | 10 ++ include/linux/posix-timers.h | 2 + include/linux/rtc.h | 3 + 6 files changed, 292 insertions(+), 1 deletions(-) create mode 100644 drivers/rtc/posix.c
drivers/rtc/Makefile +1 -1
@@ -9,7 +9,7 @@ endif obj-$(CONFIG_RTC_LIB) += rtc-lib.o obj-$(CONFIG_RTC_HCTOSYS) += hctosys.o obj-$(CONFIG_RTC_CLASS) += rtc-core.o -rtc-core-y := class.o interface.o +rtc-core-y := class.o interface.o posix.o rtc-core-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o rtc-core-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o
drivers/rtc/class.c +2 -0
@@ -173,6 +173,8 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev, rtc->pie_timer.function = rtc_pie_update_irq; rtc->pie_enabled =0 ; +init_rtc_posix_timer (rtc); +strlcpy (rtc->name, name,RTC_DEVICE_NAME_SIZE );dev_set_name (&rtc->dev,"rtc%d" , id);
drivers/rtc/posix.c new file +274 -0
274 lines not on this page · raw message
drivers/rtc/rtc-sysfs.c +10 -0
@@ -81,6 +81,15 @@ rtc_sysfs_show_since_epoch(struct device *dev, struct device_attribute *attr, }static ssize_t +rtc_sysfs_show_posix_clockid (struct device *dev,struct device_attribute *attr, +char *buf) +{ +ssize_t retval; + retval =sprintf (buf,"%lu\n" ,to_rtc_device (dev)->posix_id); +return retval; +} + +static ssize_t rtc_sysfs_show_max_user_freq (struct device *dev,struct device_attribute *attr,char *buf) {
@@ -121,6 +130,7 @@ static struct device_attribute rtc_attrs[] = {__ATTR (date,S_IRUGO , rtc_sysfs_show_date,NULL ),__ATTR (time,S_IRUGO , rtc_sysfs_show_time,NULL ),__ATTR (since_epoch,S_IRUGO , rtc_sysfs_show_since_epoch,NULL ), +__ATTR (posix_clockid,S_IRUGO , rtc_sysfs_show_posix_clockid,NULL ),__ATTR (max_user_freq,S_IRUGO |S_IWUSR , rtc_sysfs_show_max_user_freq, rtc_sysfs_set_max_user_freq), __ATTR(hctosys, S_IRUGO, rtc_sysfs_show_hctosys, NULL),
include/linux/posix-timers.h +2 -0
@@ -4,6 +4,7 @@#include <linux/spinlock.h> #include <linux/list.h> #include <linux/sched.h> +#include <linux/rtc.h> union cpu_time_count {cputime_t cpu;
@@ -63,6 +64,7 @@ struct k_itimer {unsigned long incr;unsigned long expires; } mmtimer; +struct rtc_timer rtctimer; } it; };
include/linux/rtc.h +3 -0
@@ -203,6 +203,8 @@ struct rtc_devicestruct hrtimer pie_timer;/* sub second exp, so needs hrtimer */ int pie_enabled;struct work_struct irqwork; + +clockid_t posix_id; };#define to_rtc_device (d) container_of(d, struct rtc_device, dev)
@@ -246,6 +248,7 @@ int rtc_register(rtc_task_t *task);int rtc_unregister (rtc_task_t *task);int rtc_control (rtc_task_t *t,unsigned int cmd,unsigned long arg); +void init_rtc_posix_timer (struct rtc_device * rtc);void rtctimer_enqueue (struct rtc_device *rtc,struct rtc_timer *timer);void rtctimer_remove (struct rtc_device *rtc,struct rtc_timer *timer);
Signature · 1 line
1.6.0.4
Re: [PATCH 4/6] [RFC] RTC: Rework RTC code to use timerlist for events
In reply to John StultzQuoted 6 lines · On Fri, 15 Oct 2010 17:38:53 -0700 John Stultz <[email protected]> wrote:
This patch reworks a large portion of the generic RTC code to in-effect virtualize the rtc interrupt code.
The current RTC interface is very much a raw hardware interface. Via the proc,
/dev/, or sysfs interfaces, applications can set the hardware to trigger interrupts in one of three modes:
[...]
If everything still works after all those changes, it seems a good thing to me ;)
Signature · 6 lines
Best regards, Alessandro Zummo, Tower Technologies - Torino, Italy http://www.towertech.it
Re: [PATCH 4/6] [RFC] RTC: Rework RTC code to use timerlist for events
Quoted 10 lines · Alessandro Zummo
Quoted 6 lines · On Fri, 15 Oct 2010 17:38:53 -0700 John Stultz <[email protected]> wrote:
This patch reworks a large portion of the generic RTC code to in-effect virtualize the rtc interrupt code.
The current RTC interface is very much a raw hardware interface. Via the proc,
/dev/, or sysfs interfaces, applications can set the hardware to trigger interrupts in one of three modes:
Quoted 5 lines
[...]
If everything still works after all those changes, it seems a good thing to me ;)
Heh, well, that's a good bit less resistance then I thought I'd get :)
Not that I'm complaining, but Is there anyone else in the RTC community that you'd recommend getting feedback from on a change this large? I just want to try to get any back-to-the-blackboard level feedback early on if possible.
Also, are there any other RTC test cases (other then whats in Documentation/rtc.txt) that you might recommend to help insure things are bug-free before submission?
thanks
-john
Re: [PATCH 1/6] [RFC] posix clocks: dynamic clock ids.
In reply to John StultzQuoted 11 lines · John Stultz
From: Richard Cochran <[email protected]>
This patch augments the POSIX clock code to offer a dynamic clock creation method. Instead of registering a hard coded clock ID, modules may call
create_posix_clock(), which returns a new clock ID.Signed-off-by Richard Cochran <[email protected]>This patch still has un-addressed lifetime issues pointed out by Alan Cox. More work is needed here, but for now this provides the functionality needed for the following patches.
I am working on a fully dynamic clock implementation in the style suggested by Alan. Using it would change some details in this RTC patch series, but not the general idea.
Should I post the dynamic clock stuff all by itself for review?
(The entire patch series including the PTP hardware clocks will take a bit longer.)
Richard
Re: [PATCH 1/6] [RFC] posix clocks: dynamic clock ids.
Quoted 13 lines · Richard Cochran
Quoted 11 lines · John Stultz
From: Richard Cochran <[email protected]>
This patch augments the POSIX clock code to offer a dynamic clock creation method. Instead of registering a hard coded clock ID, modules may call
create_posix_clock(), which returns a new clock ID.Signed-off-by Richard Cochran <[email protected]>This patch still has un-addressed lifetime issues pointed out by Alan Cox. More work is needed here, but for now this provides the functionality needed for the following patches.
Quoted 5 lines
I am working on a fully dynamic clock implementation in the style suggested by Alan. Using it would change some details in this RTC patch series, but not the general idea.
Should I post the dynamic clock stuff all by itself for review?
Yea, that'd be great!
thanks!
-john
Re: [PATCH 1/6] [RFC] posix clocks: dynamic clock ids.
In reply to Richard CochranQuoted 13 lines · Richard Cochran
Quoted 11 lines · John Stultz
From: Richard Cochran <[email protected]>
This patch augments the POSIX clock code to offer a dynamic clock creation method. Instead of registering a hard coded clock ID, modules may call
create_posix_clock(), which returns a new clock ID.Signed-off-by Richard Cochran <[email protected]>This patch still has un-addressed lifetime issues pointed out by Alan Cox. More work is needed here, but for now this provides the functionality needed for the following patches.
Quoted 5 lines
I am working on a fully dynamic clock implementation in the style suggested by Alan. Using it would change some details in this RTC patch series, but not the general idea.
Should I post the dynamic clock stuff all by itself for review?
Incremental is preferred. We all know by now what it's going to be used for.
Thanks,
tglx