LCOV - code coverage report
Current view: top level - kernel/time - alarmtimer.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 43 348 12.4 %
Date: 2022-03-28 13:20:08 Functions: 2 33 6.1 %
Branches: 12 149 8.1 %

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

Generated by: LCOV version 1.14