~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/time/alarmtimer.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Alarmtimer interface
  3  *
  4  * This interface provides a timer which is similarto hrtimers,
  5  * but triggers a RTC alarm if the box is suspend.
  6  *
  7  * This interface is influenced by the Android RTC Alarm timer
  8  * interface.
  9  *
 10  * Copyright (C) 2010 IBM Corperation
 11  *
 12  * Author: John Stultz <john.stultz@linaro.org>
 13  *
 14  * This program is free software; you can redistribute it and/or modify
 15  * it under the terms of the GNU General Public License version 2 as
 16  * published by the Free Software Foundation.
 17  */
 18 #include <linux/time.h>
 19 #include <linux/hrtimer.h>
 20 #include <linux/timerqueue.h>
 21 #include <linux/rtc.h>
 22 #include <linux/alarmtimer.h>
 23 #include <linux/mutex.h>
 24 #include <linux/platform_device.h>
 25 #include <linux/posix-timers.h>
 26 #include <linux/workqueue.h>
 27 #include <linux/freezer.h>
 28 
 29 /**
 30  * struct alarm_base - Alarm timer bases
 31  * @lock:               Lock for syncrhonized access to the base
 32  * @timerqueue:         Timerqueue head managing the list of events
 33  * @timer:              hrtimer used to schedule events while running
 34  * @gettime:            Function to read the time correlating to the base
 35  * @base_clockid:       clockid for the base
 36  */
 37 static struct alarm_base {
 38         spinlock_t              lock;
 39         struct timerqueue_head  timerqueue;
 40         struct hrtimer          timer;
 41         ktime_t                 (*gettime)(void);
 42         clockid_t               base_clockid;
 43 } alarm_bases[ALARM_NUMTYPE];
 44 
 45 /* freezer delta & lock used to handle clock_nanosleep triggered wakeups */
 46 static ktime_t freezer_delta;
 47 static DEFINE_SPINLOCK(freezer_delta_lock);
 48 
 49 #ifdef CONFIG_RTC_CLASS
 50 /* rtc timer and device for setting alarm wakeups at suspend */
 51 static struct rtc_timer         rtctimer;
 52 static struct rtc_device        *rtcdev;
 53 static DEFINE_SPINLOCK(rtcdev_lock);
 54 
 55 /**
 56  * alarmtimer_get_rtcdev - Return selected rtcdevice
 57  *
 58  * This function returns the rtc device to use for wakealarms.
 59  * If one has not already been chosen, it checks to see if a
 60  * functional rtc device is available.
 61  */
 62 struct rtc_device *alarmtimer_get_rtcdev(void)
 63 {
 64         unsigned long flags;
 65         struct rtc_device *ret;
 66 
 67         spin_lock_irqsave(&rtcdev_lock, flags);
 68         ret = rtcdev;
 69         spin_unlock_irqrestore(&rtcdev_lock, flags);
 70 
 71         return ret;
 72 }
 73 
 74 
 75 static int alarmtimer_rtc_add_device(struct device *dev,
 76                                 struct class_interface *class_intf)
 77 {
 78         unsigned long flags;
 79         struct rtc_device *rtc = to_rtc_device(dev);
 80 
 81         if (rtcdev)
 82                 return -EBUSY;
 83 
 84         if (!rtc->ops->set_alarm)
 85                 return -1;
 86         if (!device_may_wakeup(rtc->dev.parent))
 87                 return -1;
 88 
 89         spin_lock_irqsave(&rtcdev_lock, flags);
 90         if (!rtcdev) {
 91                 rtcdev = rtc;
 92                 /* hold a reference so it doesn't go away */
 93                 get_device(dev);
 94         }
 95         spin_unlock_irqrestore(&rtcdev_lock, flags);
 96         return 0;
 97 }
 98 
 99 static inline void alarmtimer_rtc_timer_init(void)
100 {
101         rtc_timer_init(&rtctimer, NULL, NULL);
102 }
103 
104 static struct class_interface alarmtimer_rtc_interface = {
105         .add_dev = &alarmtimer_rtc_add_device,
106 };
107 
108 static int alarmtimer_rtc_interface_setup(void)
109 {
110         alarmtimer_rtc_interface.class = rtc_class;
111         return class_interface_register(&alarmtimer_rtc_interface);
112 }
113 static void alarmtimer_rtc_interface_remove(void)
114 {
115         class_interface_unregister(&alarmtimer_rtc_interface);
116 }
117 #else
118 struct rtc_device *alarmtimer_get_rtcdev(void)
119 {
120         return NULL;
121 }
122 #define rtcdev (NULL)
123 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
124 static inline void alarmtimer_rtc_interface_remove(void) { }
125 static inline void alarmtimer_rtc_timer_init(void) { }
126 #endif
127 
128 /**
129  * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
130  * @base: pointer to the base where the timer is being run
131  * @alarm: pointer to alarm being enqueued.
132  *
133  * Adds alarm to a alarm_base timerqueue and if necessary sets
134  * an hrtimer to run.
135  *
136  * Must hold base->lock when calling.
137  */
138 static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
139 {
140         timerqueue_add(&base->timerqueue, &alarm->node);
141         alarm->state |= ALARMTIMER_STATE_ENQUEUED;
142 
143         if (&alarm->node == timerqueue_getnext(&base->timerqueue)) {
144                 hrtimer_try_to_cancel(&base->timer);
145                 hrtimer_start(&base->timer, alarm->node.expires,
146                                 HRTIMER_MODE_ABS);
147         }
148 }
149 
150 /**
151  * alarmtimer_remove - Removes an alarm timer from an alarm_base timerqueue
152  * @base: pointer to the base where the timer is running
153  * @alarm: pointer to alarm being removed
154  *
155  * Removes alarm to a alarm_base timerqueue and if necessary sets
156  * a new timer to run.
157  *
158  * Must hold base->lock when calling.
159  */
160 static void alarmtimer_remove(struct alarm_base *base, struct alarm *alarm)
161 {
162         struct timerqueue_node *next = timerqueue_getnext(&base->timerqueue);
163 
164         if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))
165                 return;
166 
167         timerqueue_del(&base->timerqueue, &alarm->node);
168         alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
169 
170         if (next == &alarm->node) {
171                 hrtimer_try_to_cancel(&base->timer);
172                 next = timerqueue_getnext(&base->timerqueue);
173                 if (!next)
174                         return;
175                 hrtimer_start(&base->timer, next->expires, HRTIMER_MODE_ABS);
176         }
177 }
178 
179 
180 /**
181  * alarmtimer_fired - Handles alarm hrtimer being fired.
182  * @timer: pointer to hrtimer being run
183  *
184  * When a alarm timer fires, this runs through the timerqueue to
185  * see which alarms expired, and runs those. If there are more alarm
186  * timers queued for the future, we set the hrtimer to fire when
187  * when the next future alarm timer expires.
188  */
189 static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
190 {
191         struct alarm_base *base = container_of(timer, struct alarm_base, timer);
192         struct timerqueue_node *next;
193         unsigned long flags;
194         ktime_t now;
195         int ret = HRTIMER_NORESTART;
196         int restart = ALARMTIMER_NORESTART;
197 
198         spin_lock_irqsave(&base->lock, flags);
199         now = base->gettime();
200         while ((next = timerqueue_getnext(&base->timerqueue))) {
201                 struct alarm *alarm;
202                 ktime_t expired = next->expires;
203 
204                 if (expired.tv64 > now.tv64)
205                         break;
206 
207                 alarm = container_of(next, struct alarm, node);
208 
209                 timerqueue_del(&base->timerqueue, &alarm->node);
210                 alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
211 
212                 alarm->state |= ALARMTIMER_STATE_CALLBACK;
213                 spin_unlock_irqrestore(&base->lock, flags);
214                 if (alarm->function)
215                         restart = alarm->function(alarm, now);
216                 spin_lock_irqsave(&base->lock, flags);
217                 alarm->state &= ~ALARMTIMER_STATE_CALLBACK;
218 
219                 if (restart != ALARMTIMER_NORESTART) {
220                         timerqueue_add(&base->timerqueue, &alarm->node);
221                         alarm->state |= ALARMTIMER_STATE_ENQUEUED;
222                 }
223         }
224 
225         if (next) {
226                 hrtimer_set_expires(&base->timer, next->expires);
227                 ret = HRTIMER_RESTART;
228         }
229         spin_unlock_irqrestore(&base->lock, flags);
230 
231         return ret;
232 
233 }
234 
235 #ifdef CONFIG_RTC_CLASS
236 /**
237  * alarmtimer_suspend - Suspend time callback
238  * @dev: unused
239  * @state: unused
240  *
241  * When we are going into suspend, we look through the bases
242  * to see which is the soonest timer to expire. We then
243  * set an rtc timer to fire that far into the future, which
244  * will wake us from suspend.
245  */
246 static int alarmtimer_suspend(struct device *dev)
247 {
248         struct rtc_time tm;
249         ktime_t min, now;
250         unsigned long flags;
251         struct rtc_device *rtc;
252         int i;
253 
254         spin_lock_irqsave(&freezer_delta_lock, flags);
255         min = freezer_delta;
256         freezer_delta = ktime_set(0, 0);
257         spin_unlock_irqrestore(&freezer_delta_lock, flags);
258 
259         rtc = alarmtimer_get_rtcdev();
260         /* If we have no rtcdev, just return */
261         if (!rtc)
262                 return 0;
263 
264         /* Find the soonest timer to expire*/
265         for (i = 0; i < ALARM_NUMTYPE; i++) {
266                 struct alarm_base *base = &alarm_bases[i];
267                 struct timerqueue_node *next;
268                 ktime_t delta;
269 
270                 spin_lock_irqsave(&base->lock, flags);
271                 next = timerqueue_getnext(&base->timerqueue);
272                 spin_unlock_irqrestore(&base->lock, flags);
273                 if (!next)
274                         continue;
275                 delta = ktime_sub(next->expires, base->gettime());
276                 if (!min.tv64 || (delta.tv64 < min.tv64))
277                         min = delta;
278         }
279         if (min.tv64 == 0)
280                 return 0;
281 
282         /* XXX - Should we enforce a minimum sleep time? */
283         WARN_ON(min.tv64 < NSEC_PER_SEC);
284 
285         /* Setup an rtc timer to fire that far in the future */
286         rtc_timer_cancel(rtc, &rtctimer);
287         rtc_read_time(rtc, &tm);
288         now = rtc_tm_to_ktime(tm);
289         now = ktime_add(now, min);
290 
291         rtc_timer_start(rtc, &rtctimer, now, ktime_set(0, 0));
292 
293         return 0;
294 }
295 #else
296 static int alarmtimer_suspend(struct device *dev)
297 {
298         return 0;
299 }
300 #endif
301 
302 static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
303 {
304         ktime_t delta;
305         unsigned long flags;
306         struct alarm_base *base = &alarm_bases[type];
307 
308         delta = ktime_sub(absexp, base->gettime());
309 
310         spin_lock_irqsave(&freezer_delta_lock, flags);
311         if (!freezer_delta.tv64 || (delta.tv64 < freezer_delta.tv64))
312                 freezer_delta = delta;
313         spin_unlock_irqrestore(&freezer_delta_lock, flags);
314 }
315 
316 
317 /**
318  * alarm_init - Initialize an alarm structure
319  * @alarm: ptr to alarm to be initialized
320  * @type: the type of the alarm
321  * @function: callback that is run when the alarm fires
322  */
323 void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
324                 enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
325 {
326         timerqueue_init(&alarm->node);
327         alarm->function = function;
328         alarm->type = type;
329         alarm->state = ALARMTIMER_STATE_INACTIVE;
330 }
331 
332 /**
333  * alarm_start - Sets an alarm to fire
334  * @alarm: ptr to alarm to set
335  * @start: time to run the alarm
336  */
337 void alarm_start(struct alarm *alarm, ktime_t start)
338 {
339         struct alarm_base *base = &alarm_bases[alarm->type];
340         unsigned long flags;
341 
342         spin_lock_irqsave(&base->lock, flags);
343         if (alarmtimer_active(alarm))
344                 alarmtimer_remove(base, alarm);
345         alarm->node.expires = start;
346         alarmtimer_enqueue(base, alarm);
347         spin_unlock_irqrestore(&base->lock, flags);
348 }
349 
350 /**
351  * alarm_try_to_cancel - Tries to cancel an alarm timer
352  * @alarm: ptr to alarm to be canceled
353  *
354  * Returns 1 if the timer was canceled, 0 if it was not running,
355  * and -1 if the callback was running
356  */
357 int alarm_try_to_cancel(struct alarm *alarm)
358 {
359         struct alarm_base *base = &alarm_bases[alarm->type];
360         unsigned long flags;
361         int ret = -1;
362         spin_lock_irqsave(&base->lock, flags);
363 
364         if (alarmtimer_callback_running(alarm))
365                 goto out;
366 
367         if (alarmtimer_is_queued(alarm)) {
368                 alarmtimer_remove(base, alarm);
369                 ret = 1;
370         } else
371                 ret = 0;
372 out:
373         spin_unlock_irqrestore(&base->lock, flags);
374         return ret;
375 }
376 
377 
378 /**
379  * alarm_cancel - Spins trying to cancel an alarm timer until it is done
380  * @alarm: ptr to alarm to be canceled
381  *
382  * Returns 1 if the timer was canceled, 0 if it was not active.
383  */
384 int alarm_cancel(struct alarm *alarm)
385 {
386         for (;;) {
387                 int ret = alarm_try_to_cancel(alarm);
388                 if (ret >= 0)
389                         return ret;
390                 cpu_relax();
391         }
392 }
393 
394 
395 u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
396 {
397         u64 overrun = 1;
398         ktime_t delta;
399 
400         delta = ktime_sub(now, alarm->node.expires);
401 
402         if (delta.tv64 < 0)
403                 return 0;
404 
405         if (unlikely(delta.tv64 >= interval.tv64)) {
406                 s64 incr = ktime_to_ns(interval);
407 
408                 overrun = ktime_divns(delta, incr);
409 
410                 alarm->node.expires = ktime_add_ns(alarm->node.expires,
411                                                         incr*overrun);
412 
413                 if (alarm->node.expires.tv64 > now.tv64)
414                         return overrun;
415                 /*
416                  * This (and the ktime_add() below) is the
417                  * correction for exact:
418                  */
419                 overrun++;
420         }
421 
422         alarm->node.expires = ktime_add(alarm->node.expires, interval);
423         return overrun;
424 }
425 
426 
427 
428 
429 /**
430  * clock2alarm - helper that converts from clockid to alarmtypes
431  * @clockid: clockid.
432  */
433 static enum alarmtimer_type clock2alarm(clockid_t clockid)
434 {
435         if (clockid == CLOCK_REALTIME_ALARM)
436                 return ALARM_REALTIME;
437         if (clockid == CLOCK_BOOTTIME_ALARM)
438                 return ALARM_BOOTTIME;
439         return -1;
440 }
441 
442 /**
443  * alarm_handle_timer - Callback for posix timers
444  * @alarm: alarm that fired
445  *
446  * Posix timer callback for expired alarm timers.
447  */
448 static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
449                                                         ktime_t now)
450 {
451         struct k_itimer *ptr = container_of(alarm, struct k_itimer,
452                                                 it.alarm.alarmtimer);
453         if (posix_timer_event(ptr, 0) != 0)
454                 ptr->it_overrun++;
455 
456         /* Re-add periodic timers */
457         if (ptr->it.alarm.interval.tv64) {
458                 ptr->it_overrun += alarm_forward(alarm, now,
459                                                 ptr->it.alarm.interval);
460                 return ALARMTIMER_RESTART;
461         }
462         return ALARMTIMER_NORESTART;
463 }
464 
465 /**
466  * alarm_clock_getres - posix getres interface
467  * @which_clock: clockid
468  * @tp: timespec to fill
469  *
470  * Returns the granularity of underlying alarm base clock
471  */
472 static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp)
473 {
474         clockid_t baseid = alarm_bases[clock2alarm(which_clock)].base_clockid;
475 
476         if (!alarmtimer_get_rtcdev())
477                 return -ENOTSUPP;
478 
479         return hrtimer_get_res(baseid, tp);
480 }
481 
482 /**
483  * alarm_clock_get - posix clock_get interface
484  * @which_clock: clockid
485  * @tp: timespec to fill.
486  *
487  * Provides the underlying alarm base time.
488  */
489 static int alarm_clock_get(clockid_t which_clock, struct timespec *tp)
490 {
491         struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
492 
493         if (!alarmtimer_get_rtcdev())
494                 return -ENOTSUPP;
495 
496         *tp = ktime_to_timespec(base->gettime());
497         return 0;
498 }
499 
500 /**
501  * alarm_timer_create - posix timer_create interface
502  * @new_timer: k_itimer pointer to manage
503  *
504  * Initializes the k_itimer structure.
505  */
506 static int alarm_timer_create(struct k_itimer *new_timer)
507 {
508         enum  alarmtimer_type type;
509         struct alarm_base *base;
510 
511         if (!alarmtimer_get_rtcdev())
512                 return -ENOTSUPP;
513 
514         if (!capable(CAP_WAKE_ALARM))
515                 return -EPERM;
516 
517         type = clock2alarm(new_timer->it_clock);
518         base = &alarm_bases[type];
519         alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
520         return 0;
521 }
522 
523 /**
524  * alarm_timer_get - posix timer_get interface
525  * @new_timer: k_itimer pointer
526  * @cur_setting: itimerspec data to fill
527  *
528  * Copies the itimerspec data out from the k_itimer
529  */
530 static void alarm_timer_get(struct k_itimer *timr,
531                                 struct itimerspec *cur_setting)
532 {
533         memset(cur_setting, 0, sizeof(struct itimerspec));
534 
535         cur_setting->it_interval =
536                         ktime_to_timespec(timr->it.alarm.interval);
537         cur_setting->it_value =
538                 ktime_to_timespec(timr->it.alarm.alarmtimer.node.expires);
539         return;
540 }
541 
542 /**
543  * alarm_timer_del - posix timer_del interface
544  * @timr: k_itimer pointer to be deleted
545  *
546  * Cancels any programmed alarms for the given timer.
547  */
548 static int alarm_timer_del(struct k_itimer *timr)
549 {
550         if (!rtcdev)
551                 return -ENOTSUPP;
552 
553         if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
554                 return TIMER_RETRY;
555 
556         return 0;
557 }
558 
559 /**
560  * alarm_timer_set - posix timer_set interface
561  * @timr: k_itimer pointer to be deleted
562  * @flags: timer flags
563  * @new_setting: itimerspec to be used
564  * @old_setting: itimerspec being replaced
565  *
566  * Sets the timer to new_setting, and starts the timer.
567  */
568 static int alarm_timer_set(struct k_itimer *timr, int flags,
569                                 struct itimerspec *new_setting,
570                                 struct itimerspec *old_setting)
571 {
572         if (!rtcdev)
573                 return -ENOTSUPP;
574 
575         if (old_setting)
576                 alarm_timer_get(timr, old_setting);
577 
578         /* If the timer was already set, cancel it */
579         if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
580                 return TIMER_RETRY;
581 
582         /* start the timer */
583         timr->it.alarm.interval = timespec_to_ktime(new_setting->it_interval);
584         alarm_start(&timr->it.alarm.alarmtimer,
585                         timespec_to_ktime(new_setting->it_value));
586         return 0;
587 }
588 
589 /**
590  * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
591  * @alarm: ptr to alarm that fired
592  *
593  * Wakes up the task that set the alarmtimer
594  */
595 static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
596                                                                 ktime_t now)
597 {
598         struct task_struct *task = (struct task_struct *)alarm->data;
599 
600         alarm->data = NULL;
601         if (task)
602                 wake_up_process(task);
603         return ALARMTIMER_NORESTART;
604 }
605 
606 /**
607  * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
608  * @alarm: ptr to alarmtimer
609  * @absexp: absolute expiration time
610  *
611  * Sets the alarm timer and sleeps until it is fired or interrupted.
612  */
613 static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
614 {
615         alarm->data = (void *)current;
616         do {
617                 set_current_state(TASK_INTERRUPTIBLE);
618                 alarm_start(alarm, absexp);
619                 if (likely(alarm->data))
620                         schedule();
621 
622                 alarm_cancel(alarm);
623         } while (alarm->data && !signal_pending(current));
624 
625         __set_current_state(TASK_RUNNING);
626 
627         return (alarm->data == NULL);
628 }
629 
630 
631 /**
632  * update_rmtp - Update remaining timespec value
633  * @exp: expiration time
634  * @type: timer type
635  * @rmtp: user pointer to remaining timepsec value
636  *
637  * Helper function that fills in rmtp value with time between
638  * now and the exp value
639  */
640 static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
641                         struct timespec __user *rmtp)
642 {
643         struct timespec rmt;
644         ktime_t rem;
645 
646         rem = ktime_sub(exp, alarm_bases[type].gettime());
647 
648         if (rem.tv64 <= 0)
649                 return 0;
650         rmt = ktime_to_timespec(rem);
651 
652         if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
653                 return -EFAULT;
654 
655         return 1;
656 
657 }
658 
659 /**
660  * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
661  * @restart: ptr to restart block
662  *
663  * Handles restarted clock_nanosleep calls
664  */
665 static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
666 {
667         enum  alarmtimer_type type = restart->nanosleep.clockid;
668         ktime_t exp;
669         struct timespec __user  *rmtp;
670         struct alarm alarm;
671         int ret = 0;
672 
673         exp.tv64 = restart->nanosleep.expires;
674         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
675 
676         if (alarmtimer_do_nsleep(&alarm, exp))
677                 goto out;
678 
679         if (freezing(current))
680                 alarmtimer_freezerset(exp, type);
681 
682         rmtp = restart->nanosleep.rmtp;
683         if (rmtp) {
684                 ret = update_rmtp(exp, type, rmtp);
685                 if (ret <= 0)
686                         goto out;
687         }
688 
689 
690         /* The other values in restart are already filled in */
691         ret = -ERESTART_RESTARTBLOCK;
692 out:
693         return ret;
694 }
695 
696 /**
697  * alarm_timer_nsleep - alarmtimer nanosleep
698  * @which_clock: clockid
699  * @flags: determins abstime or relative
700  * @tsreq: requested sleep time (abs or rel)
701  * @rmtp: remaining sleep time saved
702  *
703  * Handles clock_nanosleep calls against _ALARM clockids
704  */
705 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
706                      struct timespec *tsreq, struct timespec __user *rmtp)
707 {
708         enum  alarmtimer_type type = clock2alarm(which_clock);
709         struct alarm alarm;
710         ktime_t exp;
711         int ret = 0;
712         struct restart_block *restart;
713 
714         if (!alarmtimer_get_rtcdev())
715                 return -ENOTSUPP;
716 
717         if (!capable(CAP_WAKE_ALARM))
718                 return -EPERM;
719 
720         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
721 
722         exp = timespec_to_ktime(*tsreq);
723         /* Convert (if necessary) to absolute time */
724         if (flags != TIMER_ABSTIME) {
725                 ktime_t now = alarm_bases[type].gettime();
726                 exp = ktime_add(now, exp);
727         }
728 
729         if (alarmtimer_do_nsleep(&alarm, exp))
730                 goto out;
731 
732         if (freezing(current))
733                 alarmtimer_freezerset(exp, type);
734 
735         /* abs timers don't set remaining time or restart */
736         if (flags == TIMER_ABSTIME) {
737                 ret = -ERESTARTNOHAND;
738                 goto out;
739         }
740 
741         if (rmtp) {
742                 ret = update_rmtp(exp, type, rmtp);
743                 if (ret <= 0)
744                         goto out;
745         }
746 
747         restart = &current_thread_info()->restart_block;
748         restart->fn = alarm_timer_nsleep_restart;
749         restart->nanosleep.clockid = type;
750         restart->nanosleep.expires = exp.tv64;
751         restart->nanosleep.rmtp = rmtp;
752         ret = -ERESTART_RESTARTBLOCK;
753 
754 out:
755         return ret;
756 }
757 
758 
759 /* Suspend hook structures */
760 static const struct dev_pm_ops alarmtimer_pm_ops = {
761         .suspend = alarmtimer_suspend,
762 };
763 
764 static struct platform_driver alarmtimer_driver = {
765         .driver = {
766                 .name = "alarmtimer",
767                 .pm = &alarmtimer_pm_ops,
768         }
769 };
770 
771 /**
772  * alarmtimer_init - Initialize alarm timer code
773  *
774  * This function initializes the alarm bases and registers
775  * the posix clock ids.
776  */
777 static int __init alarmtimer_init(void)
778 {
779         struct platform_device *pdev;
780         int error = 0;
781         int i;
782         struct k_clock alarm_clock = {
783                 .clock_getres   = alarm_clock_getres,
784                 .clock_get      = alarm_clock_get,
785                 .timer_create   = alarm_timer_create,
786                 .timer_set      = alarm_timer_set,
787                 .timer_del      = alarm_timer_del,
788                 .timer_get      = alarm_timer_get,
789                 .nsleep         = alarm_timer_nsleep,
790         };
791 
792         alarmtimer_rtc_timer_init();
793 
794         posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
795         posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
796 
797         /* Initialize alarm bases */
798         alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
799         alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
800         alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
801         alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
802         for (i = 0; i < ALARM_NUMTYPE; i++) {
803                 timerqueue_init_head(&alarm_bases[i].timerqueue);
804                 spin_lock_init(&alarm_bases[i].lock);
805                 hrtimer_init(&alarm_bases[i].timer,
806                                 alarm_bases[i].base_clockid,
807                                 HRTIMER_MODE_ABS);
808                 alarm_bases[i].timer.function = alarmtimer_fired;
809         }
810 
811         error = alarmtimer_rtc_interface_setup();
812         if (error)
813                 return error;
814 
815         error = platform_driver_register(&alarmtimer_driver);
816         if (error)
817                 goto out_if;
818 
819         pdev = platform_device_register_simple("alarmtimer", -1, NULL, 0);
820         if (IS_ERR(pdev)) {
821                 error = PTR_ERR(pdev);
822                 goto out_drv;
823         }
824         return 0;
825 
826 out_drv:
827         platform_driver_unregister(&alarmtimer_driver);
828 out_if:
829         alarmtimer_rtc_interface_remove();
830         return error;
831 }
832 device_initcall(alarmtimer_init);
833 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp