kernel/time/alarmtimer.c

   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/sched/signal.h>
  23 #include <linux/sched/debug.h>
  24 #include <linux/alarmtimer.h>
  25 #include <linux/mutex.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/posix-timers.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/freezer.h>
  30
  31 #include "posix-timers.h"
  32
  33 #define CREATE_TRACE_POINTS
  34 #include <trace/events/alarmtimer.h>
  35
  36 /**
  37  * struct alarm_base - Alarm timer bases
  38  * @lock:               Lock for syncrhonized access to the base
  39  * @timerqueue:         Timerqueue head managing the list of events
  40  * @gettime:            Function to read the time correlating to the base
  41  * @base_clockid:       clockid for the base
  42  */
  43 static struct alarm_base {
  44         spinlock_t              lock;
  45         struct timerqueue_head  timerqueue;
  46         ktime_t                 (*gettime)(void);
  47         clockid_t               base_clockid;
  48 } alarm_bases[ALARM_NUMTYPE];
  49
  50 #if defined(CONFIG_POSIX_TIMERS) || defined(CONFIG_RTC_CLASS)
  51 /* freezer information to handle clock_nanosleep triggered wakeups */
  52 static enum alarmtimer_type freezer_alarmtype;
  53 static ktime_t freezer_expires;
  54 static ktime_t freezer_delta;
  55 static DEFINE_SPINLOCK(freezer_delta_lock);
  56 #endif
  57
  58 static struct wakeup_source *ws;
  59
  60 #ifdef CONFIG_RTC_CLASS
  61 /* rtc timer and device for setting alarm wakeups at suspend */
  62 static struct rtc_timer         rtctimer;
  63 static struct rtc_device        *rtcdev;
  64 static DEFINE_SPINLOCK(rtcdev_lock);
  65
  66 /**
  67  * alarmtimer_get_rtcdev - Return selected rtcdevice
  68  *
  69  * This function returns the rtc device to use for wakealarms.
  70  * If one has not already been chosen, it checks to see if a
  71  * functional rtc device is available.
  72  */
  73 struct rtc_device *alarmtimer_get_rtcdev(void)
  74 {
  75         unsigned long flags;
  76         struct rtc_device *ret;
  77
  78         spin_lock_irqsave(&rtcdev_lock, flags);
  79         ret = rtcdev;
  80         spin_unlock_irqrestore(&rtcdev_lock, flags);
  81
  82         return ret;
  83 }
  84 EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev);
  85
  86 static int alarmtimer_rtc_add_device(struct device *dev,
  87                                 struct class_interface *class_intf)
  88 {
  89         unsigned long flags;
  90         struct rtc_device *rtc = to_rtc_device(dev);
  91
  92         if (rtcdev)
  93                 return -EBUSY;
  94
  95         if (!rtc->ops->set_alarm)
  96                 return -1;
  97         if (!device_may_wakeup(rtc->dev.parent))
  98                 return -1;
  99
 100         spin_lock_irqsave(&rtcdev_lock, flags);
 101         if (!rtcdev) {
 102                 rtcdev = rtc;
 103                 /* hold a reference so it doesn't go away */
 104                 get_device(dev);
 105         }
 106         spin_unlock_irqrestore(&rtcdev_lock, flags);
 107         return 0;
 108 }
 109
 110 static inline void alarmtimer_rtc_timer_init(void)
 111 {
 112         rtc_timer_init(&rtctimer, NULL, NULL);
 113 }
 114
 115 static struct class_interface alarmtimer_rtc_interface = {
 116         .add_dev = &alarmtimer_rtc_add_device,
 117 };
 118
 119 static int alarmtimer_rtc_interface_setup(void)
 120 {
 121         alarmtimer_rtc_interface.class = rtc_class;
 122         return class_interface_register(&alarmtimer_rtc_interface);
 123 }
 124 static void alarmtimer_rtc_interface_remove(void)
 125 {
 126         class_interface_unregister(&alarmtimer_rtc_interface);
 127 }
 128 #else
 129 struct rtc_device *alarmtimer_get_rtcdev(void)
 130 {
 131         return NULL;
 132 }
 133 #define rtcdev (NULL)
 134 static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
 135 static inline void alarmtimer_rtc_interface_remove(void) { }
 136 static inline void alarmtimer_rtc_timer_init(void) { }
 137 #endif
 138
 139 /**
 140  * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
 141  * @base: pointer to the base where the timer is being run
 142  * @alarm: pointer to alarm being enqueued.
 143  *
 144  * Adds alarm to a alarm_base timerqueue
 145  *
 146  * Must hold base->lock when calling.
 147  */
 148 static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
 149 {
 150         if (alarm->state & ALARMTIMER_STATE_ENQUEUED)
 151                 timerqueue_del(&base->timerqueue, &alarm->node);
 152
 153         timerqueue_add(&base->timerqueue, &alarm->node);
 154         alarm->state |= ALARMTIMER_STATE_ENQUEUED;
 155 }
 156
 157 /**
 158  * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
 159  * @base: pointer to the base where the timer is running
 160  * @alarm: pointer to alarm being removed
 161  *
 162  * Removes alarm to a alarm_base timerqueue
 163  *
 164  * Must hold base->lock when calling.
 165  */
 166 static void alarmtimer_dequeue(struct alarm_base *base, struct alarm *alarm)
 167 {
 168         if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))
 169                 return;
 170
 171         timerqueue_del(&base->timerqueue, &alarm->node);
 172         alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
 173 }
 174
 175
 176 /**
 177  * alarmtimer_fired - Handles alarm hrtimer being fired.
 178  * @timer: pointer to hrtimer being run
 179  *
 180  * When a alarm timer fires, this runs through the timerqueue to
 181  * see which alarms expired, and runs those. If there are more alarm
 182  * timers queued for the future, we set the hrtimer to fire when
 183  * when the next future alarm timer expires.
 184  */
 185 static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
 186 {
 187         struct alarm *alarm = container_of(timer, struct alarm, timer);
 188         struct alarm_base *base = &alarm_bases[alarm->type];
 189         unsigned long flags;
 190         int ret = HRTIMER_NORESTART;
 191         int restart = ALARMTIMER_NORESTART;
 192
 193         spin_lock_irqsave(&base->lock, flags);
 194         alarmtimer_dequeue(base, alarm);
 195         spin_unlock_irqrestore(&base->lock, flags);
 196
 197         if (alarm->function)
 198                 restart = alarm->function(alarm, base->gettime());
 199
 200         spin_lock_irqsave(&base->lock, flags);
 201         if (restart != ALARMTIMER_NORESTART) {
 202                 hrtimer_set_expires(&alarm->timer, alarm->node.expires);
 203                 alarmtimer_enqueue(base, alarm);
 204                 ret = HRTIMER_RESTART;
 205         }
 206         spin_unlock_irqrestore(&base->lock, flags);
 207
 208         trace_alarmtimer_fired(alarm, base->gettime());
 209         return ret;
 210
 211 }
 212
 213 ktime_t alarm_expires_remaining(const struct alarm *alarm)
 214 {
 215         struct alarm_base *base = &alarm_bases[alarm->type];
 216         return ktime_sub(alarm->node.expires, base->gettime());
 217 }
 218 EXPORT_SYMBOL_GPL(alarm_expires_remaining);
 219
 220 #ifdef CONFIG_RTC_CLASS
 221 /**
 222  * alarmtimer_suspend - Suspend time callback
 223  * @dev: unused
 224  * @state: unused
 225  *
 226  * When we are going into suspend, we look through the bases
 227  * to see which is the soonest timer to expire. We then
 228  * set an rtc timer to fire that far into the future, which
 229  * will wake us from suspend.
 230  */
 231 static int alarmtimer_suspend(struct device *dev)
 232 {
 233         ktime_t min, now, expires;
 234         int i, ret, type;
 235         struct rtc_device *rtc;
 236         unsigned long flags;
 237         struct rtc_time tm;
 238
 239         spin_lock_irqsave(&freezer_delta_lock, flags);
 240         min = freezer_delta;
 241         expires = freezer_expires;
 242         type = freezer_alarmtype;
 243         freezer_delta = 0;
 244         spin_unlock_irqrestore(&freezer_delta_lock, flags);
 245
 246         rtc = alarmtimer_get_rtcdev();
 247         /* If we have no rtcdev, just return */
 248         if (!rtc)
 249                 return 0;
 250
 251         /* Find the soonest timer to expire*/
 252         for (i = 0; i < ALARM_NUMTYPE; i++) {
 253                 struct alarm_base *base = &alarm_bases[i];
 254                 struct timerqueue_node *next;
 255                 ktime_t delta;
 256
 257                 spin_lock_irqsave(&base->lock, flags);
 258                 next = timerqueue_getnext(&base->timerqueue);
 259                 spin_unlock_irqrestore(&base->lock, flags);
 260                 if (!next)
 261                         continue;
 262                 delta = ktime_sub(next->expires, base->gettime());
 263                 if (!min || (delta < min)) {
 264                         expires = next->expires;
 265                         min = delta;
 266                         type = i;
 267                 }
 268         }
 269         if (min == 0)
 270                 return 0;
 271
 272         if (ktime_to_ns(min) < 2 * NSEC_PER_SEC) {
 273                 __pm_wakeup_event(ws, 2 * MSEC_PER_SEC);
 274                 return -EBUSY;
 275         }
 276
 277         trace_alarmtimer_suspend(expires, type);
 278
 279         /* Setup an rtc timer to fire that far in the future */
 280         rtc_timer_cancel(rtc, &rtctimer);
 281         rtc_read_time(rtc, &tm);
 282         now = rtc_tm_to_ktime(tm);
 283         now = ktime_add(now, min);
 284
 285         /* Set alarm, if in the past reject suspend briefly to handle */
 286         ret = rtc_timer_start(rtc, &rtctimer, now, 0);
 287         if (ret < 0)
 288                 __pm_wakeup_event(ws, MSEC_PER_SEC);
 289         return ret;
 290 }
 291
 292 static int alarmtimer_resume(struct device *dev)
 293 {
 294         struct rtc_device *rtc;
 295
 296         rtc = alarmtimer_get_rtcdev();
 297         if (rtc)
 298                 rtc_timer_cancel(rtc, &rtctimer);
 299         return 0;
 300 }
 301
 302 #else
 303 static int alarmtimer_suspend(struct device *dev)
 304 {
 305         return 0;
 306 }
 307
 308 static int alarmtimer_resume(struct device *dev)
 309 {
 310         return 0;
 311 }
 312 #endif
 313
 314 /**
 315  * alarm_init - Initialize an alarm structure
 316  * @alarm: ptr to alarm to be initialized
 317  * @type: the type of the alarm
 318  * @function: callback that is run when the alarm fires
 319  */
 320 void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
 321                 enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
 322 {
 323         timerqueue_init(&alarm->node);
 324         hrtimer_init(&alarm->timer, alarm_bases[type].base_clockid,
 325                         HRTIMER_MODE_ABS);
 326         alarm->timer.function = alarmtimer_fired;
 327         alarm->function = function;
 328         alarm->type = type;
 329         alarm->state = ALARMTIMER_STATE_INACTIVE;
 330 }
 331 EXPORT_SYMBOL_GPL(alarm_init);
 332
 333 /**
 334  * alarm_start - Sets an absolute alarm to fire
 335  * @alarm: ptr to alarm to set
 336  * @start: time to run the alarm
 337  */
 338 void alarm_start(struct alarm *alarm, ktime_t start)
 339 {
 340         struct alarm_base *base = &alarm_bases[alarm->type];
 341         unsigned long flags;
 342
 343         spin_lock_irqsave(&base->lock, flags);
 344         alarm->node.expires = start;
 345         alarmtimer_enqueue(base, alarm);
 346         hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS);
 347         spin_unlock_irqrestore(&base->lock, flags);
 348
 349         trace_alarmtimer_start(alarm, base->gettime());
 350 }
 351 EXPORT_SYMBOL_GPL(alarm_start);
 352
 353 /**
 354  * alarm_start_relative - Sets a relative alarm to fire
 355  * @alarm: ptr to alarm to set
 356  * @start: time relative to now to run the alarm
 357  */
 358 void alarm_start_relative(struct alarm *alarm, ktime_t start)
 359 {
 360         struct alarm_base *base = &alarm_bases[alarm->type];
 361
 362         start = ktime_add_safe(start, base->gettime());
 363         alarm_start(alarm, start);
 364 }
 365 EXPORT_SYMBOL_GPL(alarm_start_relative);
 366
 367 void alarm_restart(struct alarm *alarm)
 368 {
 369         struct alarm_base *base = &alarm_bases[alarm->type];
 370         unsigned long flags;
 371
 372         spin_lock_irqsave(&base->lock, flags);
 373         hrtimer_set_expires(&alarm->timer, alarm->node.expires);
 374         hrtimer_restart(&alarm->timer);
 375         alarmtimer_enqueue(base, alarm);
 376         spin_unlock_irqrestore(&base->lock, flags);
 377 }
 378 EXPORT_SYMBOL_GPL(alarm_restart);
 379
 380 /**
 381  * alarm_try_to_cancel - Tries to cancel an alarm timer
 382  * @alarm: ptr to alarm to be canceled
 383  *
 384  * Returns 1 if the timer was canceled, 0 if it was not running,
 385  * and -1 if the callback was running
 386  */
 387 int alarm_try_to_cancel(struct alarm *alarm)
 388 {
 389         struct alarm_base *base = &alarm_bases[alarm->type];
 390         unsigned long flags;
 391         int ret;
 392
 393         spin_lock_irqsave(&base->lock, flags);
 394         ret = hrtimer_try_to_cancel(&alarm->timer);
 395         if (ret >= 0)
 396                 alarmtimer_dequeue(base, alarm);
 397         spin_unlock_irqrestore(&base->lock, flags);
 398
 399         trace_alarmtimer_cancel(alarm, base->gettime());
 400         return ret;
 401 }
 402 EXPORT_SYMBOL_GPL(alarm_try_to_cancel);
 403
 404
 405 /**
 406  * alarm_cancel - Spins trying to cancel an alarm timer until it is done
 407  * @alarm: ptr to alarm to be canceled
 408  *
 409  * Returns 1 if the timer was canceled, 0 if it was not active.
 410  */
 411 int alarm_cancel(struct alarm *alarm)
 412 {
 413         for (;;) {
 414                 int ret = alarm_try_to_cancel(alarm);
 415                 if (ret >= 0)
 416                         return ret;
 417                 cpu_relax();
 418         }
 419 }
 420 EXPORT_SYMBOL_GPL(alarm_cancel);
 421
 422
 423 u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
 424 {
 425         u64 overrun = 1;
 426         ktime_t delta;
 427
 428         delta = ktime_sub(now, alarm->node.expires);
 429
 430         if (delta < 0)
 431                 return 0;
 432
 433         if (unlikely(delta >= interval)) {
 434                 s64 incr = ktime_to_ns(interval);
 435
 436                 overrun = ktime_divns(delta, incr);
 437
 438                 alarm->node.expires = ktime_add_ns(alarm->node.expires,
 439                                                         incr*overrun);
 440
 441                 if (alarm->node.expires > now)
 442                         return overrun;
 443                 /*
 444                  * This (and the ktime_add() below) is the
 445                  * correction for exact:
 446                  */
 447                 overrun++;
 448         }
 449
 450         alarm->node.expires = ktime_add_safe(alarm->node.expires, interval);
 451         return overrun;
 452 }
 453 EXPORT_SYMBOL_GPL(alarm_forward);
 454
 455 u64 alarm_forward_now(struct alarm *alarm, ktime_t interval)
 456 {
 457         struct alarm_base *base = &alarm_bases[alarm->type];
 458
 459         return alarm_forward(alarm, base->gettime(), interval);
 460 }
 461 EXPORT_SYMBOL_GPL(alarm_forward_now);
 462
 463 #ifdef CONFIG_POSIX_TIMERS
 464
 465 static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
 466 {
 467         struct alarm_base *base;
 468         unsigned long flags;
 469         ktime_t delta;
 470
 471         switch(type) {
 472         case ALARM_REALTIME:
 473                 base = &alarm_bases[ALARM_REALTIME];
 474                 type = ALARM_REALTIME_FREEZER;
 475                 break;
 476         case ALARM_BOOTTIME:
 477                 base = &alarm_bases[ALARM_BOOTTIME];
 478                 type = ALARM_BOOTTIME_FREEZER;
 479                 break;
 480         default:
 481                 WARN_ONCE(1, "Invalid alarm type: %d\n", type);
 482                 return;
 483         }
 484
 485         delta = ktime_sub(absexp, base->gettime());
 486
 487         spin_lock_irqsave(&freezer_delta_lock, flags);
 488         if (!freezer_delta || (delta < freezer_delta)) {
 489                 freezer_delta = delta;
 490                 freezer_expires = absexp;
 491                 freezer_alarmtype = type;
 492         }
 493         spin_unlock_irqrestore(&freezer_delta_lock, flags);
 494 }
 495
 496 /**
 497  * clock2alarm - helper that converts from clockid to alarmtypes
 498  * @clockid: clockid.
 499  */
 500 static enum alarmtimer_type clock2alarm(clockid_t clockid)
 501 {
 502         if (clockid == CLOCK_REALTIME_ALARM)
 503                 return ALARM_REALTIME;
 504         if (clockid == CLOCK_BOOTTIME_ALARM)
 505                 return ALARM_BOOTTIME;
 506         return -1;
 507 }
 508
 509 /**
 510  * alarm_handle_timer - Callback for posix timers
 511  * @alarm: alarm that fired
 512  *
 513  * Posix timer callback for expired alarm timers.
 514  */
 515 static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
 516                                                         ktime_t now)
 517 {
 518         unsigned long flags;
 519         struct k_itimer *ptr = container_of(alarm, struct k_itimer,
 520                                                 it.alarm.alarmtimer);
 521         enum alarmtimer_restart result = ALARMTIMER_NORESTART;
 522
 523         spin_lock_irqsave(&ptr->it_lock, flags);
 524         if ((ptr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) {
 525                 if (posix_timer_event(ptr, 0))
 526                         ptr->it_overrun++;
 527         }
 528
 529         /* Re-add periodic timers */
 530         if (ptr->it_interval) {
 531                 ptr->it_overrun += alarm_forward(alarm, now, ptr->it_interval);
 532                 result = ALARMTIMER_RESTART;
 533         }
 534         spin_unlock_irqrestore(&ptr->it_lock, flags);
 535
 536         return result;
 537 }
 538
 539 /**
 540  * alarm_timer_rearm - Posix timer callback for rearming timer
 541  * @timr:       Pointer to the posixtimer data struct
 542  */
 543 static void alarm_timer_rearm(struct k_itimer *timr)
 544 {
 545         struct alarm *alarm = &timr->it.alarm.alarmtimer;
 546
 547         timr->it_overrun += alarm_forward_now(alarm, timr->it_interval);
 548         alarm_start(alarm, alarm->node.expires);
 549 }
 550
 551 /**
 552  * alarm_timer_forward - Posix timer callback for forwarding timer
 553  * @timr:       Pointer to the posixtimer data struct
 554  * @now:        Current time to forward the timer against
 555  */
 556 static int alarm_timer_forward(struct k_itimer *timr, ktime_t now)
 557 {
 558         struct alarm *alarm = &timr->it.alarm.alarmtimer;
 559
 560         return (int) alarm_forward(alarm, timr->it_interval, now);
 561 }
 562
 563 /**
 564  * alarm_timer_remaining - Posix timer callback to retrieve remaining time
 565  * @timr:       Pointer to the posixtimer data struct
 566  * @now:        Current time to calculate against
 567  */
 568 static ktime_t alarm_timer_remaining(struct k_itimer *timr, ktime_t now)
 569 {
 570         struct alarm *alarm = &timr->it.alarm.alarmtimer;
 571
 572         return ktime_sub(now, alarm->node.expires);
 573 }
 574
 575 /**
 576  * alarm_timer_try_to_cancel - Posix timer callback to cancel a timer
 577  * @timr:       Pointer to the posixtimer data struct
 578  */
 579 static int alarm_timer_try_to_cancel(struct k_itimer *timr)
 580 {
 581         return alarm_try_to_cancel(&timr->it.alarm.alarmtimer);
 582 }
 583
 584 /**
 585  * alarm_timer_arm - Posix timer callback to arm a timer
 586  * @timr:       Pointer to the posixtimer data struct
 587  * @expires:    The new expiry time
 588  * @absolute:   Expiry value is absolute time
 589  * @sigev_none: Posix timer does not deliver signals
 590  */
 591 static void alarm_timer_arm(struct k_itimer *timr, ktime_t expires,
 592                             bool absolute, bool sigev_none)
 593 {
 594         struct alarm *alarm = &timr->it.alarm.alarmtimer;
 595         struct alarm_base *base = &alarm_bases[alarm->type];
 596
 597         if (!absolute)
 598                 expires = ktime_add_safe(expires, base->gettime());
 599         if (sigev_none)
 600                 alarm->node.expires = expires;
 601         else
 602                 alarm_start(&timr->it.alarm.alarmtimer, expires);
 603 }
 604
 605 /**
 606  * alarm_clock_getres - posix getres interface
 607  * @which_clock: clockid
 608  * @tp: timespec to fill
 609  *
 610  * Returns the granularity of underlying alarm base clock
 611  */
 612 static int alarm_clock_getres(const clockid_t which_clock, struct timespec64 *tp)
 613 {
 614         if (!alarmtimer_get_rtcdev())
 615                 return -EINVAL;
 616
 617         tp->tv_sec = 0;
 618         tp->tv_nsec = hrtimer_resolution;
 619         return 0;
 620 }
 621
 622 /**
 623  * alarm_clock_get - posix clock_get interface
 624  * @which_clock: clockid
 625  * @tp: timespec to fill.
 626  *
 627  * Provides the underlying alarm base time.
 628  */
 629 static int alarm_clock_get(clockid_t which_clock, struct timespec64 *tp)
 630 {
 631         struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
 632
 633         if (!alarmtimer_get_rtcdev())
 634                 return -EINVAL;
 635
 636         *tp = ktime_to_timespec64(base->gettime());
 637         return 0;
 638 }
 639
 640 /**
 641  * alarm_timer_create - posix timer_create interface
 642  * @new_timer: k_itimer pointer to manage
 643  *
 644  * Initializes the k_itimer structure.
 645  */
 646 static int alarm_timer_create(struct k_itimer *new_timer)
 647 {
 648         enum  alarmtimer_type type;
 649
 650         if (!alarmtimer_get_rtcdev())
 651                 return -ENOTSUPP;
 652
 653         if (!capable(CAP_WAKE_ALARM))
 654                 return -EPERM;
 655
 656         type = clock2alarm(new_timer->it_clock);
 657         alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
 658         return 0;
 659 }
 660
 661 /**
 662  * alarm_timer_get - posix timer_get interface
 663  * @timr: k_itimer pointer
 664  * @cur_setting: itimerspec data to fill
 665  *
 666  * Copies out the current itimerspec data
 667  */
 668 static void alarm_timer_get(struct k_itimer *timr,
 669                             struct itimerspec64 *cur_setting)
 670 {
 671         ktime_t relative_expiry_time =
 672                 alarm_expires_remaining(&(timr->it.alarm.alarmtimer));
 673
 674         if (ktime_to_ns(relative_expiry_time) > 0) {
 675                 cur_setting->it_value = ktime_to_timespec64(relative_expiry_time);
 676         } else {
 677                 cur_setting->it_value.tv_sec = 0;
 678                 cur_setting->it_value.tv_nsec = 0;
 679         }
 680
 681         cur_setting->it_interval = ktime_to_timespec64(timr->it_interval);
 682 }
 683
 684 /**
 685  * alarm_timer_del - posix timer_del interface
 686  * @timr: k_itimer pointer to be deleted
 687  *
 688  * Cancels any programmed alarms for the given timer.
 689  */
 690 static int alarm_timer_del(struct k_itimer *timr)
 691 {
 692         if (!rtcdev)
 693                 return -ENOTSUPP;
 694
 695         if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
 696                 return TIMER_RETRY;
 697
 698         return 0;
 699 }
 700
 701 /**
 702  * alarm_timer_set - posix timer_set interface
 703  * @timr: k_itimer pointer to be deleted
 704  * @flags: timer flags
 705  * @new_setting: itimerspec to be used
 706  * @old_setting: itimerspec being replaced
 707  *
 708  * Sets the timer to new_setting, and starts the timer.
 709  */
 710 static int alarm_timer_set(struct k_itimer *timr, int flags,
 711                            struct itimerspec64 *new_setting,
 712                            struct itimerspec64 *old_setting)
 713 {
 714         ktime_t exp;
 715
 716         if (!rtcdev)
 717                 return -ENOTSUPP;
 718
 719         if (flags & ~TIMER_ABSTIME)
 720                 return -EINVAL;
 721
 722         if (old_setting)
 723                 alarm_timer_get(timr, old_setting);
 724
 725         /* If the timer was already set, cancel it */
 726         if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
 727                 return TIMER_RETRY;
 728
 729         /* start the timer */
 730         timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
 731
 732         /*
 733          * Rate limit to the tick as a hot fix to prevent DOS. Will be
 734          * mopped up later.
 735          */
 736         if (timr->it_interval < TICK_NSEC)
 737                 timr->it_interval = TICK_NSEC;
 738
 739         exp = timespec64_to_ktime(new_setting->it_value);
 740         /* Convert (if necessary) to absolute time */
 741         if (flags != TIMER_ABSTIME) {
 742                 ktime_t now;
 743
 744                 now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
 745                 exp = ktime_add_safe(now, exp);
 746         }
 747
 748         alarm_start(&timr->it.alarm.alarmtimer, exp);
 749         return 0;
 750 }
 751
 752 /**
 753  * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
 754  * @alarm: ptr to alarm that fired
 755  *
 756  * Wakes up the task that set the alarmtimer
 757  */
 758 static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
 759                                                                 ktime_t now)
 760 {
 761         struct task_struct *task = (struct task_struct *)alarm->data;
 762
 763         alarm->data = NULL;
 764         if (task)
 765                 wake_up_process(task);
 766         return ALARMTIMER_NORESTART;
 767 }
 768
 769 /**
 770  * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
 771  * @alarm: ptr to alarmtimer
 772  * @absexp: absolute expiration time
 773  *
 774  * Sets the alarm timer and sleeps until it is fired or interrupted.
 775  */
 776 static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
 777 {
 778         alarm->data = (void *)current;
 779         do {
 780                 set_current_state(TASK_INTERRUPTIBLE);
 781                 alarm_start(alarm, absexp);
 782                 if (likely(alarm->data))
 783                         schedule();
 784
 785                 alarm_cancel(alarm);
 786         } while (alarm->data && !signal_pending(current));
 787
 788         __set_current_state(TASK_RUNNING);
 789
 790         return (alarm->data == NULL);
 791 }
 792
 793
 794 /**
 795  * update_rmtp - Update remaining timespec value
 796  * @exp: expiration time
 797  * @type: timer type
 798  * @rmtp: user pointer to remaining timepsec value
 799  *
 800  * Helper function that fills in rmtp value with time between
 801  * now and the exp value
 802  */
 803 static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
 804                         struct timespec __user *rmtp)
 805 {
 806         struct timespec rmt;
 807         ktime_t rem;
 808
 809         rem = ktime_sub(exp, alarm_bases[type].gettime());
 810
 811         if (rem <= 0)
 812                 return 0;
 813         rmt = ktime_to_timespec(rem);
 814
 815         if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
 816                 return -EFAULT;
 817
 818         return 1;
 819
 820 }
 821
 822 /**
 823  * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
 824  * @restart: ptr to restart block
 825  *
 826  * Handles restarted clock_nanosleep calls
 827  */
 828 static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
 829 {
 830         enum  alarmtimer_type type = restart->nanosleep.clockid;
 831         ktime_t exp;
 832         struct timespec __user  *rmtp;
 833         struct alarm alarm;
 834         int ret = 0;
 835
 836         exp = restart->nanosleep.expires;
 837         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
 838
 839         if (alarmtimer_do_nsleep(&alarm, exp))
 840                 goto out;
 841
 842         if (freezing(current))
 843                 alarmtimer_freezerset(exp, type);
 844
 845         rmtp = restart->nanosleep.rmtp;
 846         if (rmtp) {
 847                 ret = update_rmtp(exp, type, rmtp);
 848                 if (ret <= 0)
 849                         goto out;
 850         }
 851
 852
 853         /* The other values in restart are already filled in */
 854         ret = -ERESTART_RESTARTBLOCK;
 855 out:
 856         return ret;
 857 }
 858
 859 /**
 860  * alarm_timer_nsleep - alarmtimer nanosleep
 861  * @which_clock: clockid
 862  * @flags: determins abstime or relative
 863  * @tsreq: requested sleep time (abs or rel)
 864  * @rmtp: remaining sleep time saved
 865  *
 866  * Handles clock_nanosleep calls against _ALARM clockids
 867  */
 868 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
 869                               struct timespec64 *tsreq,
 870                               struct timespec __user *rmtp)
 871 {
 872         enum  alarmtimer_type type = clock2alarm(which_clock);
 873         struct restart_block *restart;
 874         struct alarm alarm;
 875         ktime_t exp;
 876         int ret = 0;
 877
 878         if (!alarmtimer_get_rtcdev())
 879                 return -ENOTSUPP;
 880
 881         if (flags & ~TIMER_ABSTIME)
 882                 return -EINVAL;
 883
 884         if (!capable(CAP_WAKE_ALARM))
 885                 return -EPERM;
 886
 887         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
 888
 889         exp = timespec64_to_ktime(*tsreq);
 890         /* Convert (if necessary) to absolute time */
 891         if (flags != TIMER_ABSTIME) {
 892                 ktime_t now = alarm_bases[type].gettime();
 893                 exp = ktime_add(now, exp);
 894         }
 895
 896         if (alarmtimer_do_nsleep(&alarm, exp))
 897                 goto out;
 898
 899         if (freezing(current))
 900                 alarmtimer_freezerset(exp, type);
 901
 902         /* abs timers don't set remaining time or restart */
 903         if (flags == TIMER_ABSTIME) {
 904                 ret = -ERESTARTNOHAND;
 905                 goto out;
 906         }
 907
 908         if (rmtp) {
 909                 ret = update_rmtp(exp, type, rmtp);
 910                 if (ret <= 0)
 911                         goto out;
 912         }
 913
 914         restart = &current->restart_block;
 915         restart->fn = alarm_timer_nsleep_restart;
 916         restart->nanosleep.clockid = type;
 917         restart->nanosleep.expires = exp;
 918         restart->nanosleep.rmtp = rmtp;
 919         ret = -ERESTART_RESTARTBLOCK;
 920
 921 out:
 922         return ret;
 923 }
 924
 925 const struct k_clock alarm_clock = {
 926         .clock_getres           = alarm_clock_getres,
 927         .clock_get              = alarm_clock_get,
 928         .timer_create           = alarm_timer_create,
 929         .timer_set              = alarm_timer_set,
 930         .timer_del              = alarm_timer_del,
 931         .timer_get              = alarm_timer_get,
 932         .timer_arm              = alarm_timer_arm,
 933         .timer_rearm            = alarm_timer_rearm,
 934         .timer_forward          = alarm_timer_forward,
 935         .timer_remaining        = alarm_timer_remaining,
 936         .timer_try_to_cancel    = alarm_timer_try_to_cancel,
 937         .nsleep                 = alarm_timer_nsleep,
 938 };
 939 #endif /* CONFIG_POSIX_TIMERS */
 940
 941
 942 /* Suspend hook structures */
 943 static const struct dev_pm_ops alarmtimer_pm_ops = {
 944         .suspend = alarmtimer_suspend,
 945         .resume = alarmtimer_resume,
 946 };
 947
 948 static struct platform_driver alarmtimer_driver = {
 949         .driver = {
 950                 .name = "alarmtimer",
 951                 .pm = &alarmtimer_pm_ops,
 952         }
 953 };
 954
 955 /**
 956  * alarmtimer_init - Initialize alarm timer code
 957  *
 958  * This function initializes the alarm bases and registers
 959  * the posix clock ids.
 960  */
 961 static int __init alarmtimer_init(void)
 962 {
 963         struct platform_device *pdev;
 964         int error = 0;
 965         int i;
 966
 967         alarmtimer_rtc_timer_init();
 968
 969         /* Initialize alarm bases */
 970         alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
 971         alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
 972         alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
 973         alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
 974         for (i = 0; i < ALARM_NUMTYPE; i++) {
 975                 timerqueue_init_head(&alarm_bases[i].timerqueue);
 976                 spin_lock_init(&alarm_bases[i].lock);
 977         }
 978
 979         error = alarmtimer_rtc_interface_setup();
 980         if (error)
 981                 return error;
 982
 983         error = platform_driver_register(&alarmtimer_driver);
 984         if (error)
 985                 goto out_if;
 986
 987         pdev = platform_device_register_simple("alarmtimer", -1, NULL, 0);
 988         if (IS_ERR(pdev)) {
 989                 error = PTR_ERR(pdev);
 990                 goto out_drv;
 991         }
 992         ws = wakeup_source_register("alarmtimer");
 993         return 0;
 994
 995 out_drv:
 996         platform_driver_unregister(&alarmtimer_driver);
 997 out_if:
 998         alarmtimer_rtc_interface_remove();
 999         return error;
1000 }
1001 device_initcall(alarmtimer_init);