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