alarmtimer.c 23 KB

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