LCOV - code coverage report
Current view: top level - kernel/time - ntp.c (source / functions) Hit Total Coverage
Test: Real Lines: 145 233 62.2 %
Date: 2020-10-17 15:46:16 Functions: 2 16 12.5 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * NTP state machine interfaces and logic.
       4                 :            :  *
       5                 :            :  * This code was mainly moved from kernel/timer.c and kernel/time.c
       6                 :            :  * Please see those files for relevant copyright info and historical
       7                 :            :  * changelogs.
       8                 :            :  */
       9                 :            : #include <linux/capability.h>
      10                 :            : #include <linux/clocksource.h>
      11                 :            : #include <linux/workqueue.h>
      12                 :            : #include <linux/hrtimer.h>
      13                 :            : #include <linux/jiffies.h>
      14                 :            : #include <linux/math64.h>
      15                 :            : #include <linux/timex.h>
      16                 :            : #include <linux/time.h>
      17                 :            : #include <linux/mm.h>
      18                 :            : #include <linux/module.h>
      19                 :            : #include <linux/rtc.h>
      20                 :            : #include <linux/audit.h>
      21                 :            : 
      22                 :            : #include "ntp_internal.h"
      23                 :            : #include "timekeeping_internal.h"
      24                 :            : 
      25                 :            : 
      26                 :            : /*
      27                 :            :  * NTP timekeeping variables:
      28                 :            :  *
      29                 :            :  * Note: All of the NTP state is protected by the timekeeping locks.
      30                 :            :  */
      31                 :            : 
      32                 :            : 
      33                 :            : /* USER_HZ period (usecs): */
      34                 :            : unsigned long                   tick_usec = USER_TICK_USEC;
      35                 :            : 
      36                 :            : /* SHIFTED_HZ period (nsecs): */
      37                 :            : unsigned long                   tick_nsec;
      38                 :            : 
      39                 :            : static u64                      tick_length;
      40                 :            : static u64                      tick_length_base;
      41                 :            : 
      42                 :            : #define SECS_PER_DAY            86400
      43                 :            : #define MAX_TICKADJ             500LL           /* usecs */
      44                 :            : #define MAX_TICKADJ_SCALED \
      45                 :            :         (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
      46                 :            : #define MAX_TAI_OFFSET          100000
      47                 :            : 
      48                 :            : /*
      49                 :            :  * phase-lock loop variables
      50                 :            :  */
      51                 :            : 
      52                 :            : /*
      53                 :            :  * clock synchronization status
      54                 :            :  *
      55                 :            :  * (TIME_ERROR prevents overwriting the CMOS clock)
      56                 :            :  */
      57                 :            : static int                      time_state = TIME_OK;
      58                 :            : 
      59                 :            : /* clock status bits:                                                   */
      60                 :            : static int                      time_status = STA_UNSYNC;
      61                 :            : 
      62                 :            : /* time adjustment (nsecs):                                             */
      63                 :            : static s64                      time_offset;
      64                 :            : 
      65                 :            : /* pll time constant:                                                   */
      66                 :            : static long                     time_constant = 2;
      67                 :            : 
      68                 :            : /* maximum error (usecs):                                               */
      69                 :            : static long                     time_maxerror = NTP_PHASE_LIMIT;
      70                 :            : 
      71                 :            : /* estimated error (usecs):                                             */
      72                 :            : static long                     time_esterror = NTP_PHASE_LIMIT;
      73                 :            : 
      74                 :            : /* frequency offset (scaled nsecs/secs):                                */
      75                 :            : static s64                      time_freq;
      76                 :            : 
      77                 :            : /* time at last adjustment (secs):                                      */
      78                 :            : static time64_t         time_reftime;
      79                 :            : 
      80                 :            : static long                     time_adjust;
      81                 :            : 
      82                 :            : /* constant (boot-param configurable) NTP tick adjustment (upscaled)    */
      83                 :            : static s64                      ntp_tick_adj;
      84                 :            : 
      85                 :            : /* second value of the next pending leapsecond, or TIME64_MAX if no leap */
      86                 :            : static time64_t                 ntp_next_leap_sec = TIME64_MAX;
      87                 :            : 
      88                 :            : #ifdef CONFIG_NTP_PPS
      89                 :            : 
      90                 :            : /*
      91                 :            :  * The following variables are used when a pulse-per-second (PPS) signal
      92                 :            :  * is available. They establish the engineering parameters of the clock
      93                 :            :  * discipline loop when controlled by the PPS signal.
      94                 :            :  */
      95                 :            : #define PPS_VALID       10      /* PPS signal watchdog max (s) */
      96                 :            : #define PPS_POPCORN     4       /* popcorn spike threshold (shift) */
      97                 :            : #define PPS_INTMIN      2       /* min freq interval (s) (shift) */
      98                 :            : #define PPS_INTMAX      8       /* max freq interval (s) (shift) */
      99                 :            : #define PPS_INTCOUNT    4       /* number of consecutive good intervals to
     100                 :            :                                    increase pps_shift or consecutive bad
     101                 :            :                                    intervals to decrease it */
     102                 :            : #define PPS_MAXWANDER   100000  /* max PPS freq wander (ns/s) */
     103                 :            : 
     104                 :            : static int pps_valid;           /* signal watchdog counter */
     105                 :            : static long pps_tf[3];          /* phase median filter */
     106                 :            : static long pps_jitter;         /* current jitter (ns) */
     107                 :            : static struct timespec64 pps_fbase; /* beginning of the last freq interval */
     108                 :            : static int pps_shift;           /* current interval duration (s) (shift) */
     109                 :            : static int pps_intcnt;          /* interval counter */
     110                 :            : static s64 pps_freq;            /* frequency offset (scaled ns/s) */
     111                 :            : static long pps_stabil;         /* current stability (scaled ns/s) */
     112                 :            : 
     113                 :            : /*
     114                 :            :  * PPS signal quality monitors
     115                 :            :  */
     116                 :            : static long pps_calcnt;         /* calibration intervals */
     117                 :            : static long pps_jitcnt;         /* jitter limit exceeded */
     118                 :            : static long pps_stbcnt;         /* stability limit exceeded */
     119                 :            : static long pps_errcnt;         /* calibration errors */
     120                 :            : 
     121                 :            : 
     122                 :            : /* PPS kernel consumer compensates the whole phase error immediately.
     123                 :            :  * Otherwise, reduce the offset by a fixed factor times the time constant.
     124                 :            :  */
     125                 :            : static inline s64 ntp_offset_chunk(s64 offset)
     126                 :            : {
     127                 :            :         if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
     128                 :            :                 return offset;
     129                 :            :         else
     130                 :            :                 return shift_right(offset, SHIFT_PLL + time_constant);
     131                 :            : }
     132                 :            : 
     133                 :            : static inline void pps_reset_freq_interval(void)
     134                 :            : {
     135                 :            :         /* the PPS calibration interval may end
     136                 :            :            surprisingly early */
     137                 :            :         pps_shift = PPS_INTMIN;
     138                 :            :         pps_intcnt = 0;
     139                 :            : }
     140                 :            : 
     141                 :            : /**
     142                 :            :  * pps_clear - Clears the PPS state variables
     143                 :            :  */
     144                 :            : static inline void pps_clear(void)
     145                 :            : {
     146                 :            :         pps_reset_freq_interval();
     147                 :            :         pps_tf[0] = 0;
     148                 :            :         pps_tf[1] = 0;
     149                 :            :         pps_tf[2] = 0;
     150                 :            :         pps_fbase.tv_sec = pps_fbase.tv_nsec = 0;
     151                 :            :         pps_freq = 0;
     152                 :            : }
     153                 :            : 
     154                 :            : /* Decrease pps_valid to indicate that another second has passed since
     155                 :            :  * the last PPS signal. When it reaches 0, indicate that PPS signal is
     156                 :            :  * missing.
     157                 :            :  */
     158                 :            : static inline void pps_dec_valid(void)
     159                 :            : {
     160                 :            :         if (pps_valid > 0)
     161                 :            :                 pps_valid--;
     162                 :            :         else {
     163                 :            :                 time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
     164                 :            :                                  STA_PPSWANDER | STA_PPSERROR);
     165                 :            :                 pps_clear();
     166                 :            :         }
     167                 :            : }
     168                 :            : 
     169                 :            : static inline void pps_set_freq(s64 freq)
     170                 :            : {
     171                 :            :         pps_freq = freq;
     172                 :            : }
     173                 :            : 
     174                 :            : static inline int is_error_status(int status)
     175                 :            : {
     176                 :            :         return (status & (STA_UNSYNC|STA_CLOCKERR))
     177                 :            :                 /* PPS signal lost when either PPS time or
     178                 :            :                  * PPS frequency synchronization requested
     179                 :            :                  */
     180                 :            :                 || ((status & (STA_PPSFREQ|STA_PPSTIME))
     181                 :            :                         && !(status & STA_PPSSIGNAL))
     182                 :            :                 /* PPS jitter exceeded when
     183                 :            :                  * PPS time synchronization requested */
     184                 :            :                 || ((status & (STA_PPSTIME|STA_PPSJITTER))
     185                 :            :                         == (STA_PPSTIME|STA_PPSJITTER))
     186                 :            :                 /* PPS wander exceeded or calibration error when
     187                 :            :                  * PPS frequency synchronization requested
     188                 :            :                  */
     189                 :            :                 || ((status & STA_PPSFREQ)
     190                 :            :                         && (status & (STA_PPSWANDER|STA_PPSERROR)));
     191                 :            : }
     192                 :            : 
     193                 :            : static inline void pps_fill_timex(struct __kernel_timex *txc)
     194                 :            : {
     195                 :            :         txc->ppsfreq    = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
     196                 :            :                                          PPM_SCALE_INV, NTP_SCALE_SHIFT);
     197                 :            :         txc->jitter     = pps_jitter;
     198                 :            :         if (!(time_status & STA_NANO))
     199                 :            :                 txc->jitter = pps_jitter / NSEC_PER_USEC;
     200                 :            :         txc->shift      = pps_shift;
     201                 :            :         txc->stabil     = pps_stabil;
     202                 :            :         txc->jitcnt     = pps_jitcnt;
     203                 :            :         txc->calcnt     = pps_calcnt;
     204                 :            :         txc->errcnt     = pps_errcnt;
     205                 :            :         txc->stbcnt     = pps_stbcnt;
     206                 :            : }
     207                 :            : 
     208                 :            : #else /* !CONFIG_NTP_PPS */
     209                 :            : 
     210                 :            : static inline s64 ntp_offset_chunk(s64 offset)
     211                 :            : {
     212                 :          3 :         return shift_right(offset, SHIFT_PLL + time_constant);
     213                 :            : }
     214                 :            : 
     215                 :            : static inline void pps_reset_freq_interval(void) {}
     216                 :            : static inline void pps_clear(void) {}
     217                 :            : static inline void pps_dec_valid(void) {}
     218                 :            : static inline void pps_set_freq(s64 freq) {}
     219                 :            : 
     220                 :            : static inline int is_error_status(int status)
     221                 :            : {
     222                 :          3 :         return status & (STA_UNSYNC|STA_CLOCKERR);
     223                 :            : }
     224                 :            : 
     225                 :            : static inline void pps_fill_timex(struct __kernel_timex *txc)
     226                 :            : {
     227                 :            :         /* PPS is not implemented, so these are zero */
     228                 :          3 :         txc->ppsfreq    = 0;
     229                 :          3 :         txc->jitter     = 0;
     230                 :          3 :         txc->shift      = 0;
     231                 :          3 :         txc->stabil     = 0;
     232                 :          3 :         txc->jitcnt     = 0;
     233                 :          3 :         txc->calcnt     = 0;
     234                 :          3 :         txc->errcnt     = 0;
     235                 :          3 :         txc->stbcnt     = 0;
     236                 :            : }
     237                 :            : 
     238                 :            : #endif /* CONFIG_NTP_PPS */
     239                 :            : 
     240                 :            : 
     241                 :            : /**
     242                 :            :  * ntp_synced - Returns 1 if the NTP status is not UNSYNC
     243                 :            :  *
     244                 :            :  */
     245                 :            : static inline int ntp_synced(void)
     246                 :            : {
     247                 :          3 :         return !(time_status & STA_UNSYNC);
     248                 :            : }
     249                 :            : 
     250                 :            : 
     251                 :            : /*
     252                 :            :  * NTP methods:
     253                 :            :  */
     254                 :            : 
     255                 :            : /*
     256                 :            :  * Update (tick_length, tick_length_base, tick_nsec), based
     257                 :            :  * on (tick_usec, ntp_tick_adj, time_freq):
     258                 :            :  */
     259                 :          3 : static void ntp_update_frequency(void)
     260                 :            : {
     261                 :            :         u64 second_length;
     262                 :            :         u64 new_base;
     263                 :            : 
     264                 :          3 :         second_length            = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
     265                 :            :                                                 << NTP_SCALE_SHIFT;
     266                 :            : 
     267                 :          3 :         second_length           += ntp_tick_adj;
     268                 :          3 :         second_length           += time_freq;
     269                 :            : 
     270                 :          3 :         tick_nsec                = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
     271                 :            :         new_base                 = div_u64(second_length, NTP_INTERVAL_FREQ);
     272                 :            : 
     273                 :            :         /*
     274                 :            :          * Don't wait for the next second_overflow, apply
     275                 :            :          * the change to the tick length immediately:
     276                 :            :          */
     277                 :          3 :         tick_length             += new_base - tick_length_base;
     278                 :          3 :         tick_length_base         = new_base;
     279                 :          3 : }
     280                 :            : 
     281                 :          3 : static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
     282                 :            : {
     283                 :          3 :         time_status &= ~STA_MODE;
     284                 :            : 
     285                 :          3 :         if (secs < MINSEC)
     286                 :            :                 return 0;
     287                 :            : 
     288                 :          0 :         if (!(time_status & STA_FLL) && (secs <= MAXSEC))
     289                 :            :                 return 0;
     290                 :            : 
     291                 :          0 :         time_status |= STA_MODE;
     292                 :            : 
     293                 :          0 :         return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
     294                 :            : }
     295                 :            : 
     296                 :          3 : static void ntp_update_offset(long offset)
     297                 :            : {
     298                 :            :         s64 freq_adj;
     299                 :            :         s64 offset64;
     300                 :            :         long secs;
     301                 :            : 
     302                 :          3 :         if (!(time_status & STA_PLL))
     303                 :          3 :                 return;
     304                 :            : 
     305                 :          3 :         if (!(time_status & STA_NANO)) {
     306                 :            :                 /* Make sure the multiplication below won't overflow */
     307                 :          0 :                 offset = clamp(offset, -USEC_PER_SEC, USEC_PER_SEC);
     308                 :          0 :                 offset *= NSEC_PER_USEC;
     309                 :            :         }
     310                 :            : 
     311                 :            :         /*
     312                 :            :          * Scale the phase adjustment and
     313                 :            :          * clamp to the operating range.
     314                 :            :          */
     315                 :          3 :         offset = clamp(offset, -MAXPHASE, MAXPHASE);
     316                 :            : 
     317                 :            :         /*
     318                 :            :          * Select how the frequency is to be controlled
     319                 :            :          * and in which mode (PLL or FLL).
     320                 :            :          */
     321                 :          3 :         secs = (long)(__ktime_get_real_seconds() - time_reftime);
     322                 :          3 :         if (unlikely(time_status & STA_FREQHOLD))
     323                 :            :                 secs = 0;
     324                 :            : 
     325                 :          3 :         time_reftime = __ktime_get_real_seconds();
     326                 :            : 
     327                 :          3 :         offset64    = offset;
     328                 :          3 :         freq_adj    = ntp_update_offset_fll(offset64, secs);
     329                 :            : 
     330                 :            :         /*
     331                 :            :          * Clamp update interval to reduce PLL gain with low
     332                 :            :          * sampling rate (e.g. intermittent network connection)
     333                 :            :          * to avoid instability.
     334                 :            :          */
     335                 :          3 :         if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
     336                 :            :                 secs = 1 << (SHIFT_PLL + 1 + time_constant);
     337                 :            : 
     338                 :          3 :         freq_adj    += (offset64 * secs) <<
     339                 :          3 :                         (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
     340                 :            : 
     341                 :          3 :         freq_adj    = min(freq_adj + time_freq, MAXFREQ_SCALED);
     342                 :            : 
     343                 :          3 :         time_freq   = max(freq_adj, -MAXFREQ_SCALED);
     344                 :            : 
     345                 :          3 :         time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
     346                 :            : }
     347                 :            : 
     348                 :            : /**
     349                 :            :  * ntp_clear - Clears the NTP state variables
     350                 :            :  */
     351                 :          3 : void ntp_clear(void)
     352                 :            : {
     353                 :          3 :         time_adjust     = 0;            /* stop active adjtime() */
     354                 :          3 :         time_status     |= STA_UNSYNC;
     355                 :          3 :         time_maxerror   = NTP_PHASE_LIMIT;
     356                 :          3 :         time_esterror   = NTP_PHASE_LIMIT;
     357                 :            : 
     358                 :          3 :         ntp_update_frequency();
     359                 :            : 
     360                 :          3 :         tick_length     = tick_length_base;
     361                 :          3 :         time_offset     = 0;
     362                 :            : 
     363                 :          3 :         ntp_next_leap_sec = TIME64_MAX;
     364                 :            :         /* Clear PPS state variables */
     365                 :            :         pps_clear();
     366                 :          3 : }
     367                 :            : 
     368                 :            : 
     369                 :          3 : u64 ntp_tick_length(void)
     370                 :            : {
     371                 :          3 :         return tick_length;
     372                 :            : }
     373                 :            : 
     374                 :            : /**
     375                 :            :  * ntp_get_next_leap - Returns the next leapsecond in CLOCK_REALTIME ktime_t
     376                 :            :  *
     377                 :            :  * Provides the time of the next leapsecond against CLOCK_REALTIME in
     378                 :            :  * a ktime_t format. Returns KTIME_MAX if no leapsecond is pending.
     379                 :            :  */
     380                 :          3 : ktime_t ntp_get_next_leap(void)
     381                 :            : {
     382                 :            :         ktime_t ret;
     383                 :            : 
     384                 :          3 :         if ((time_state == TIME_INS) && (time_status & STA_INS))
     385                 :          0 :                 return ktime_set(ntp_next_leap_sec, 0);
     386                 :            :         ret = KTIME_MAX;
     387                 :            :         return ret;
     388                 :            : }
     389                 :            : 
     390                 :            : /*
     391                 :            :  * this routine handles the overflow of the microsecond field
     392                 :            :  *
     393                 :            :  * The tricky bits of code to handle the accurate clock support
     394                 :            :  * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
     395                 :            :  * They were originally developed for SUN and DEC kernels.
     396                 :            :  * All the kudos should go to Dave for this stuff.
     397                 :            :  *
     398                 :            :  * Also handles leap second processing, and returns leap offset
     399                 :            :  */
     400                 :          3 : int second_overflow(time64_t secs)
     401                 :            : {
     402                 :            :         s64 delta;
     403                 :            :         int leap = 0;
     404                 :            :         s32 rem;
     405                 :            : 
     406                 :            :         /*
     407                 :            :          * Leap second processing. If in leap-insert state at the end of the
     408                 :            :          * day, the system clock is set back one second; if in leap-delete
     409                 :            :          * state, the system clock is set ahead one second.
     410                 :            :          */
     411                 :          3 :         switch (time_state) {
     412                 :            :         case TIME_OK:
     413                 :          3 :                 if (time_status & STA_INS) {
     414                 :          0 :                         time_state = TIME_INS;
     415                 :          0 :                         div_s64_rem(secs, SECS_PER_DAY, &rem);
     416                 :          0 :                         ntp_next_leap_sec = secs + SECS_PER_DAY - rem;
     417                 :          3 :                 } else if (time_status & STA_DEL) {
     418                 :          0 :                         time_state = TIME_DEL;
     419                 :          0 :                         div_s64_rem(secs + 1, SECS_PER_DAY, &rem);
     420                 :          0 :                         ntp_next_leap_sec = secs + SECS_PER_DAY - rem;
     421                 :            :                 }
     422                 :            :                 break;
     423                 :            :         case TIME_INS:
     424                 :          0 :                 if (!(time_status & STA_INS)) {
     425                 :          0 :                         ntp_next_leap_sec = TIME64_MAX;
     426                 :          0 :                         time_state = TIME_OK;
     427                 :          0 :                 } else if (secs == ntp_next_leap_sec) {
     428                 :            :                         leap = -1;
     429                 :          0 :                         time_state = TIME_OOP;
     430                 :          0 :                         printk(KERN_NOTICE
     431                 :            :                                 "Clock: inserting leap second 23:59:60 UTC\n");
     432                 :            :                 }
     433                 :            :                 break;
     434                 :            :         case TIME_DEL:
     435                 :          0 :                 if (!(time_status & STA_DEL)) {
     436                 :          0 :                         ntp_next_leap_sec = TIME64_MAX;
     437                 :          0 :                         time_state = TIME_OK;
     438                 :          0 :                 } else if (secs == ntp_next_leap_sec) {
     439                 :            :                         leap = 1;
     440                 :          0 :                         ntp_next_leap_sec = TIME64_MAX;
     441                 :          0 :                         time_state = TIME_WAIT;
     442                 :          0 :                         printk(KERN_NOTICE
     443                 :            :                                 "Clock: deleting leap second 23:59:59 UTC\n");
     444                 :            :                 }
     445                 :            :                 break;
     446                 :            :         case TIME_OOP:
     447                 :          0 :                 ntp_next_leap_sec = TIME64_MAX;
     448                 :          0 :                 time_state = TIME_WAIT;
     449                 :          0 :                 break;
     450                 :            :         case TIME_WAIT:
     451                 :          0 :                 if (!(time_status & (STA_INS | STA_DEL)))
     452                 :          0 :                         time_state = TIME_OK;
     453                 :            :                 break;
     454                 :            :         }
     455                 :            : 
     456                 :            : 
     457                 :            :         /* Bump the maxerror field */
     458                 :          3 :         time_maxerror += MAXFREQ / NSEC_PER_USEC;
     459                 :          3 :         if (time_maxerror > NTP_PHASE_LIMIT) {
     460                 :          3 :                 time_maxerror = NTP_PHASE_LIMIT;
     461                 :          3 :                 time_status |= STA_UNSYNC;
     462                 :            :         }
     463                 :            : 
     464                 :            :         /* Compute the phase adjustment for the next second */
     465                 :          3 :         tick_length      = tick_length_base;
     466                 :            : 
     467                 :          3 :         delta            = ntp_offset_chunk(time_offset);
     468                 :          3 :         time_offset     -= delta;
     469                 :          3 :         tick_length     += delta;
     470                 :            : 
     471                 :            :         /* Check PPS signal */
     472                 :            :         pps_dec_valid();
     473                 :            : 
     474                 :          3 :         if (!time_adjust)
     475                 :            :                 goto out;
     476                 :            : 
     477                 :          0 :         if (time_adjust > MAX_TICKADJ) {
     478                 :          0 :                 time_adjust -= MAX_TICKADJ;
     479                 :          0 :                 tick_length += MAX_TICKADJ_SCALED;
     480                 :          0 :                 goto out;
     481                 :            :         }
     482                 :            : 
     483                 :          0 :         if (time_adjust < -MAX_TICKADJ) {
     484                 :          0 :                 time_adjust += MAX_TICKADJ;
     485                 :          0 :                 tick_length -= MAX_TICKADJ_SCALED;
     486                 :          0 :                 goto out;
     487                 :            :         }
     488                 :            : 
     489                 :          0 :         tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
     490                 :          0 :                                                          << NTP_SCALE_SHIFT;
     491                 :          0 :         time_adjust = 0;
     492                 :            : 
     493                 :            : out:
     494                 :          3 :         return leap;
     495                 :            : }
     496                 :            : 
     497                 :            : static void sync_hw_clock(struct work_struct *work);
     498                 :            : static DECLARE_DELAYED_WORK(sync_work, sync_hw_clock);
     499                 :            : 
     500                 :          0 : static void sched_sync_hw_clock(struct timespec64 now,
     501                 :            :                                 unsigned long target_nsec, bool fail)
     502                 :            : 
     503                 :            : {
     504                 :            :         struct timespec64 next;
     505                 :            : 
     506                 :          0 :         ktime_get_real_ts64(&next);
     507                 :          0 :         if (!fail)
     508                 :          0 :                 next.tv_sec = 659;
     509                 :            :         else {
     510                 :            :                 /*
     511                 :            :                  * Try again as soon as possible. Delaying long periods
     512                 :            :                  * decreases the accuracy of the work queue timer. Due to this
     513                 :            :                  * the algorithm is very likely to require a short-sleep retry
     514                 :            :                  * after the above long sleep to synchronize ts_nsec.
     515                 :            :                  */
     516                 :          0 :                 next.tv_sec = 0;
     517                 :            :         }
     518                 :            : 
     519                 :            :         /* Compute the needed delay that will get to tv_nsec == target_nsec */
     520                 :          0 :         next.tv_nsec = target_nsec - next.tv_nsec;
     521                 :          0 :         if (next.tv_nsec <= 0)
     522                 :          0 :                 next.tv_nsec += NSEC_PER_SEC;
     523                 :          0 :         if (next.tv_nsec >= NSEC_PER_SEC) {
     524                 :          0 :                 next.tv_sec++;
     525                 :          0 :                 next.tv_nsec -= NSEC_PER_SEC;
     526                 :            :         }
     527                 :            : 
     528                 :          0 :         queue_delayed_work(system_power_efficient_wq, &sync_work,
     529                 :            :                            timespec64_to_jiffies(&next));
     530                 :          0 : }
     531                 :            : 
     532                 :          3 : static void sync_rtc_clock(void)
     533                 :            : {
     534                 :            :         unsigned long target_nsec;
     535                 :            :         struct timespec64 adjust, now;
     536                 :            :         int rc;
     537                 :            : 
     538                 :            :         if (!IS_ENABLED(CONFIG_RTC_SYSTOHC))
     539                 :          3 :                 return;
     540                 :            : 
     541                 :          3 :         ktime_get_real_ts64(&now);
     542                 :            : 
     543                 :          3 :         adjust = now;
     544                 :          3 :         if (persistent_clock_is_local)
     545                 :          0 :                 adjust.tv_sec -= (sys_tz.tz_minuteswest * 60);
     546                 :            : 
     547                 :            :         /*
     548                 :            :          * The current RTC in use will provide the target_nsec it wants to be
     549                 :            :          * called at, and does rtc_tv_nsec_ok internally.
     550                 :            :          */
     551                 :          3 :         rc = rtc_set_ntp_time(adjust, &target_nsec);
     552                 :          3 :         if (rc == -ENODEV)
     553                 :            :                 return;
     554                 :            : 
     555                 :          0 :         sched_sync_hw_clock(now, target_nsec, rc);
     556                 :            : }
     557                 :            : 
     558                 :            : #ifdef CONFIG_GENERIC_CMOS_UPDATE
     559                 :            : int __weak update_persistent_clock64(struct timespec64 now64)
     560                 :            : {
     561                 :            :         return -ENODEV;
     562                 :            : }
     563                 :            : #endif
     564                 :            : 
     565                 :            : static bool sync_cmos_clock(void)
     566                 :            : {
     567                 :            :         static bool no_cmos;
     568                 :            :         struct timespec64 now;
     569                 :            :         struct timespec64 adjust;
     570                 :            :         int rc = -EPROTO;
     571                 :            :         long target_nsec = NSEC_PER_SEC / 2;
     572                 :            : 
     573                 :            :         if (!IS_ENABLED(CONFIG_GENERIC_CMOS_UPDATE))
     574                 :            :                 return false;
     575                 :            : 
     576                 :            :         if (no_cmos)
     577                 :            :                 return false;
     578                 :            : 
     579                 :            :         /*
     580                 :            :          * Historically update_persistent_clock64() has followed x86
     581                 :            :          * semantics, which match the MC146818A/etc RTC. This RTC will store
     582                 :            :          * 'adjust' and then in .5s it will advance once second.
     583                 :            :          *
     584                 :            :          * Architectures are strongly encouraged to use rtclib and not
     585                 :            :          * implement this legacy API.
     586                 :            :          */
     587                 :            :         ktime_get_real_ts64(&now);
     588                 :            :         if (rtc_tv_nsec_ok(-1 * target_nsec, &adjust, &now)) {
     589                 :            :                 if (persistent_clock_is_local)
     590                 :            :                         adjust.tv_sec -= (sys_tz.tz_minuteswest * 60);
     591                 :            :                 rc = update_persistent_clock64(adjust);
     592                 :            :                 /*
     593                 :            :                  * The machine does not support update_persistent_clock64 even
     594                 :            :                  * though it defines CONFIG_GENERIC_CMOS_UPDATE.
     595                 :            :                  */
     596                 :            :                 if (rc == -ENODEV) {
     597                 :            :                         no_cmos = true;
     598                 :            :                         return false;
     599                 :            :                 }
     600                 :            :         }
     601                 :            : 
     602                 :            :         sched_sync_hw_clock(now, target_nsec, rc);
     603                 :            :         return true;
     604                 :            : }
     605                 :            : 
     606                 :            : /*
     607                 :            :  * If we have an externally synchronized Linux clock, then update RTC clock
     608                 :            :  * accordingly every ~11 minutes. Generally RTCs can only store second
     609                 :            :  * precision, but many RTCs will adjust the phase of their second tick to
     610                 :            :  * match the moment of update. This infrastructure arranges to call to the RTC
     611                 :            :  * set at the correct moment to phase synchronize the RTC second tick over
     612                 :            :  * with the kernel clock.
     613                 :            :  */
     614                 :          3 : static void sync_hw_clock(struct work_struct *work)
     615                 :            : {
     616                 :          3 :         if (!ntp_synced())
     617                 :            :                 return;
     618                 :            : 
     619                 :            :         if (sync_cmos_clock())
     620                 :            :                 return;
     621                 :            : 
     622                 :          3 :         sync_rtc_clock();
     623                 :            : }
     624                 :            : 
     625                 :          3 : void ntp_notify_cmos_timer(void)
     626                 :            : {
     627                 :          3 :         if (!ntp_synced())
     628                 :          3 :                 return;
     629                 :            : 
     630                 :            :         if (IS_ENABLED(CONFIG_GENERIC_CMOS_UPDATE) ||
     631                 :            :             IS_ENABLED(CONFIG_RTC_SYSTOHC))
     632                 :          3 :                 queue_delayed_work(system_power_efficient_wq, &sync_work, 0);
     633                 :            : }
     634                 :            : 
     635                 :            : /*
     636                 :            :  * Propagate a new txc->status value into the NTP state:
     637                 :            :  */
     638                 :          3 : static inline void process_adj_status(const struct __kernel_timex *txc)
     639                 :            : {
     640                 :          3 :         if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
     641                 :          0 :                 time_state = TIME_OK;
     642                 :          0 :                 time_status = STA_UNSYNC;
     643                 :          0 :                 ntp_next_leap_sec = TIME64_MAX;
     644                 :            :                 /* restart PPS frequency calibration */
     645                 :            :                 pps_reset_freq_interval();
     646                 :            :         }
     647                 :            : 
     648                 :            :         /*
     649                 :            :          * If we turn on PLL adjustments then reset the
     650                 :            :          * reference time to current time.
     651                 :            :          */
     652                 :          3 :         if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
     653                 :          3 :                 time_reftime = __ktime_get_real_seconds();
     654                 :            : 
     655                 :            :         /* only set allowed bits */
     656                 :          3 :         time_status &= STA_RONLY;
     657                 :          3 :         time_status |= txc->status & ~STA_RONLY;
     658                 :          3 : }
     659                 :            : 
     660                 :            : 
     661                 :          3 : static inline void process_adjtimex_modes(const struct __kernel_timex *txc,
     662                 :            :                                           s32 *time_tai)
     663                 :            : {
     664                 :          3 :         if (txc->modes & ADJ_STATUS)
     665                 :          3 :                 process_adj_status(txc);
     666                 :            : 
     667                 :          3 :         if (txc->modes & ADJ_NANO)
     668                 :          3 :                 time_status |= STA_NANO;
     669                 :            : 
     670                 :          3 :         if (txc->modes & ADJ_MICRO)
     671                 :          0 :                 time_status &= ~STA_NANO;
     672                 :            : 
     673                 :          3 :         if (txc->modes & ADJ_FREQUENCY) {
     674                 :          0 :                 time_freq = txc->freq * PPM_SCALE;
     675                 :          0 :                 time_freq = min(time_freq, MAXFREQ_SCALED);
     676                 :          0 :                 time_freq = max(time_freq, -MAXFREQ_SCALED);
     677                 :            :                 /* update pps_freq */
     678                 :            :                 pps_set_freq(time_freq);
     679                 :            :         }
     680                 :            : 
     681                 :          3 :         if (txc->modes & ADJ_MAXERROR)
     682                 :          3 :                 time_maxerror = txc->maxerror;
     683                 :            : 
     684                 :          3 :         if (txc->modes & ADJ_ESTERROR)
     685                 :          3 :                 time_esterror = txc->esterror;
     686                 :            : 
     687                 :          3 :         if (txc->modes & ADJ_TIMECONST) {
     688                 :          3 :                 time_constant = txc->constant;
     689                 :          3 :                 if (!(time_status & STA_NANO))
     690                 :          0 :                         time_constant += 4;
     691                 :          3 :                 time_constant = min(time_constant, (long)MAXTC);
     692                 :          3 :                 time_constant = max(time_constant, 0l);
     693                 :            :         }
     694                 :            : 
     695                 :          3 :         if (txc->modes & ADJ_TAI &&
     696                 :          0 :                         txc->constant >= 0 && txc->constant <= MAX_TAI_OFFSET)
     697                 :          0 :                 *time_tai = txc->constant;
     698                 :            : 
     699                 :          3 :         if (txc->modes & ADJ_OFFSET)
     700                 :          3 :                 ntp_update_offset(txc->offset);
     701                 :            : 
     702                 :          3 :         if (txc->modes & ADJ_TICK)
     703                 :          0 :                 tick_usec = txc->tick;
     704                 :            : 
     705                 :          3 :         if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
     706                 :          3 :                 ntp_update_frequency();
     707                 :          3 : }
     708                 :            : 
     709                 :            : 
     710                 :            : /*
     711                 :            :  * adjtimex mainly allows reading (and writing, if superuser) of
     712                 :            :  * kernel time-keeping variables. used by xntpd.
     713                 :            :  */
     714                 :          3 : int __do_adjtimex(struct __kernel_timex *txc, const struct timespec64 *ts,
     715                 :            :                   s32 *time_tai, struct audit_ntp_data *ad)
     716                 :            : {
     717                 :            :         int result;
     718                 :            : 
     719                 :          3 :         if (txc->modes & ADJ_ADJTIME) {
     720                 :          0 :                 long save_adjust = time_adjust;
     721                 :            : 
     722                 :          0 :                 if (!(txc->modes & ADJ_OFFSET_READONLY)) {
     723                 :            :                         /* adjtime() is independent from ntp_adjtime() */
     724                 :          0 :                         time_adjust = txc->offset;
     725                 :          0 :                         ntp_update_frequency();
     726                 :            : 
     727                 :          0 :                         audit_ntp_set_old(ad, AUDIT_NTP_ADJUST, save_adjust);
     728                 :          0 :                         audit_ntp_set_new(ad, AUDIT_NTP_ADJUST, time_adjust);
     729                 :            :                 }
     730                 :          0 :                 txc->offset = save_adjust;
     731                 :            :         } else {
     732                 :            :                 /* If there are input parameters, then process them: */
     733                 :          3 :                 if (txc->modes) {
     734                 :          3 :                         audit_ntp_set_old(ad, AUDIT_NTP_OFFSET, time_offset);
     735                 :          3 :                         audit_ntp_set_old(ad, AUDIT_NTP_FREQ,   time_freq);
     736                 :          3 :                         audit_ntp_set_old(ad, AUDIT_NTP_STATUS, time_status);
     737                 :          3 :                         audit_ntp_set_old(ad, AUDIT_NTP_TAI,    *time_tai);
     738                 :          3 :                         audit_ntp_set_old(ad, AUDIT_NTP_TICK,   tick_usec);
     739                 :            : 
     740                 :          3 :                         process_adjtimex_modes(txc, time_tai);
     741                 :            : 
     742                 :          3 :                         audit_ntp_set_new(ad, AUDIT_NTP_OFFSET, time_offset);
     743                 :          3 :                         audit_ntp_set_new(ad, AUDIT_NTP_FREQ,   time_freq);
     744                 :          3 :                         audit_ntp_set_new(ad, AUDIT_NTP_STATUS, time_status);
     745                 :          3 :                         audit_ntp_set_new(ad, AUDIT_NTP_TAI,    *time_tai);
     746                 :          3 :                         audit_ntp_set_new(ad, AUDIT_NTP_TICK,   tick_usec);
     747                 :            :                 }
     748                 :            : 
     749                 :          3 :                 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
     750                 :            :                                   NTP_SCALE_SHIFT);
     751                 :          3 :                 if (!(time_status & STA_NANO))
     752                 :          0 :                         txc->offset = (u32)txc->offset / NSEC_PER_USEC;
     753                 :            :         }
     754                 :            : 
     755                 :          3 :         result = time_state;    /* mostly `TIME_OK' */
     756                 :            :         /* check for errors */
     757                 :          3 :         if (is_error_status(time_status))
     758                 :            :                 result = TIME_ERROR;
     759                 :            : 
     760                 :          3 :         txc->freq       = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
     761                 :            :                                          PPM_SCALE_INV, NTP_SCALE_SHIFT);
     762                 :          3 :         txc->maxerror           = time_maxerror;
     763                 :          3 :         txc->esterror           = time_esterror;
     764                 :          3 :         txc->status     = time_status;
     765                 :          3 :         txc->constant           = time_constant;
     766                 :          3 :         txc->precision          = 1;
     767                 :          3 :         txc->tolerance          = MAXFREQ_SCALED / PPM_SCALE;
     768                 :          3 :         txc->tick       = tick_usec;
     769                 :          3 :         txc->tai        = *time_tai;
     770                 :            : 
     771                 :            :         /* fill PPS status fields */
     772                 :            :         pps_fill_timex(txc);
     773                 :            : 
     774                 :          3 :         txc->time.tv_sec = ts->tv_sec;
     775                 :          3 :         txc->time.tv_usec = ts->tv_nsec;
     776                 :          3 :         if (!(time_status & STA_NANO))
     777                 :          0 :                 txc->time.tv_usec = ts->tv_nsec / NSEC_PER_USEC;
     778                 :            : 
     779                 :            :         /* Handle leapsec adjustments */
     780                 :          3 :         if (unlikely(ts->tv_sec >= ntp_next_leap_sec)) {
     781                 :          0 :                 if ((time_state == TIME_INS) && (time_status & STA_INS)) {
     782                 :            :                         result = TIME_OOP;
     783                 :          0 :                         txc->tai++;
     784                 :          0 :                         txc->time.tv_sec--;
     785                 :            :                 }
     786                 :          0 :                 if ((time_state == TIME_DEL) && (time_status & STA_DEL)) {
     787                 :            :                         result = TIME_WAIT;
     788                 :          0 :                         txc->tai--;
     789                 :          0 :                         txc->time.tv_sec++;
     790                 :            :                 }
     791                 :          0 :                 if ((time_state == TIME_OOP) &&
     792                 :          0 :                                         (ts->tv_sec == ntp_next_leap_sec)) {
     793                 :            :                         result = TIME_WAIT;
     794                 :            :                 }
     795                 :            :         }
     796                 :            : 
     797                 :          3 :         return result;
     798                 :            : }
     799                 :            : 
     800                 :            : #ifdef  CONFIG_NTP_PPS
     801                 :            : 
     802                 :            : /* actually struct pps_normtime is good old struct timespec, but it is
     803                 :            :  * semantically different (and it is the reason why it was invented):
     804                 :            :  * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
     805                 :            :  * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
     806                 :            : struct pps_normtime {
     807                 :            :         s64             sec;    /* seconds */
     808                 :            :         long            nsec;   /* nanoseconds */
     809                 :            : };
     810                 :            : 
     811                 :            : /* normalize the timestamp so that nsec is in the
     812                 :            :    ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
     813                 :            : static inline struct pps_normtime pps_normalize_ts(struct timespec64 ts)
     814                 :            : {
     815                 :            :         struct pps_normtime norm = {
     816                 :            :                 .sec = ts.tv_sec,
     817                 :            :                 .nsec = ts.tv_nsec
     818                 :            :         };
     819                 :            : 
     820                 :            :         if (norm.nsec > (NSEC_PER_SEC >> 1)) {
     821                 :            :                 norm.nsec -= NSEC_PER_SEC;
     822                 :            :                 norm.sec++;
     823                 :            :         }
     824                 :            : 
     825                 :            :         return norm;
     826                 :            : }
     827                 :            : 
     828                 :            : /* get current phase correction and jitter */
     829                 :            : static inline long pps_phase_filter_get(long *jitter)
     830                 :            : {
     831                 :            :         *jitter = pps_tf[0] - pps_tf[1];
     832                 :            :         if (*jitter < 0)
     833                 :            :                 *jitter = -*jitter;
     834                 :            : 
     835                 :            :         /* TODO: test various filters */
     836                 :            :         return pps_tf[0];
     837                 :            : }
     838                 :            : 
     839                 :            : /* add the sample to the phase filter */
     840                 :            : static inline void pps_phase_filter_add(long err)
     841                 :            : {
     842                 :            :         pps_tf[2] = pps_tf[1];
     843                 :            :         pps_tf[1] = pps_tf[0];
     844                 :            :         pps_tf[0] = err;
     845                 :            : }
     846                 :            : 
     847                 :            : /* decrease frequency calibration interval length.
     848                 :            :  * It is halved after four consecutive unstable intervals.
     849                 :            :  */
     850                 :            : static inline void pps_dec_freq_interval(void)
     851                 :            : {
     852                 :            :         if (--pps_intcnt <= -PPS_INTCOUNT) {
     853                 :            :                 pps_intcnt = -PPS_INTCOUNT;
     854                 :            :                 if (pps_shift > PPS_INTMIN) {
     855                 :            :                         pps_shift--;
     856                 :            :                         pps_intcnt = 0;
     857                 :            :                 }
     858                 :            :         }
     859                 :            : }
     860                 :            : 
     861                 :            : /* increase frequency calibration interval length.
     862                 :            :  * It is doubled after four consecutive stable intervals.
     863                 :            :  */
     864                 :            : static inline void pps_inc_freq_interval(void)
     865                 :            : {
     866                 :            :         if (++pps_intcnt >= PPS_INTCOUNT) {
     867                 :            :                 pps_intcnt = PPS_INTCOUNT;
     868                 :            :                 if (pps_shift < PPS_INTMAX) {
     869                 :            :                         pps_shift++;
     870                 :            :                         pps_intcnt = 0;
     871                 :            :                 }
     872                 :            :         }
     873                 :            : }
     874                 :            : 
     875                 :            : /* update clock frequency based on MONOTONIC_RAW clock PPS signal
     876                 :            :  * timestamps
     877                 :            :  *
     878                 :            :  * At the end of the calibration interval the difference between the
     879                 :            :  * first and last MONOTONIC_RAW clock timestamps divided by the length
     880                 :            :  * of the interval becomes the frequency update. If the interval was
     881                 :            :  * too long, the data are discarded.
     882                 :            :  * Returns the difference between old and new frequency values.
     883                 :            :  */
     884                 :            : static long hardpps_update_freq(struct pps_normtime freq_norm)
     885                 :            : {
     886                 :            :         long delta, delta_mod;
     887                 :            :         s64 ftemp;
     888                 :            : 
     889                 :            :         /* check if the frequency interval was too long */
     890                 :            :         if (freq_norm.sec > (2 << pps_shift)) {
     891                 :            :                 time_status |= STA_PPSERROR;
     892                 :            :                 pps_errcnt++;
     893                 :            :                 pps_dec_freq_interval();
     894                 :            :                 printk_deferred(KERN_ERR
     895                 :            :                         "hardpps: PPSERROR: interval too long - %lld s\n",
     896                 :            :                         freq_norm.sec);
     897                 :            :                 return 0;
     898                 :            :         }
     899                 :            : 
     900                 :            :         /* here the raw frequency offset and wander (stability) is
     901                 :            :          * calculated. If the wander is less than the wander threshold
     902                 :            :          * the interval is increased; otherwise it is decreased.
     903                 :            :          */
     904                 :            :         ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
     905                 :            :                         freq_norm.sec);
     906                 :            :         delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
     907                 :            :         pps_freq = ftemp;
     908                 :            :         if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
     909                 :            :                 printk_deferred(KERN_WARNING
     910                 :            :                                 "hardpps: PPSWANDER: change=%ld\n", delta);
     911                 :            :                 time_status |= STA_PPSWANDER;
     912                 :            :                 pps_stbcnt++;
     913                 :            :                 pps_dec_freq_interval();
     914                 :            :         } else {        /* good sample */
     915                 :            :                 pps_inc_freq_interval();
     916                 :            :         }
     917                 :            : 
     918                 :            :         /* the stability metric is calculated as the average of recent
     919                 :            :          * frequency changes, but is used only for performance
     920                 :            :          * monitoring
     921                 :            :          */
     922                 :            :         delta_mod = delta;
     923                 :            :         if (delta_mod < 0)
     924                 :            :                 delta_mod = -delta_mod;
     925                 :            :         pps_stabil += (div_s64(((s64)delta_mod) <<
     926                 :            :                                 (NTP_SCALE_SHIFT - SHIFT_USEC),
     927                 :            :                                 NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;
     928                 :            : 
     929                 :            :         /* if enabled, the system clock frequency is updated */
     930                 :            :         if ((time_status & STA_PPSFREQ) != 0 &&
     931                 :            :             (time_status & STA_FREQHOLD) == 0) {
     932                 :            :                 time_freq = pps_freq;
     933                 :            :                 ntp_update_frequency();
     934                 :            :         }
     935                 :            : 
     936                 :            :         return delta;
     937                 :            : }
     938                 :            : 
     939                 :            : /* correct REALTIME clock phase error against PPS signal */
     940                 :            : static void hardpps_update_phase(long error)
     941                 :            : {
     942                 :            :         long correction = -error;
     943                 :            :         long jitter;
     944                 :            : 
     945                 :            :         /* add the sample to the median filter */
     946                 :            :         pps_phase_filter_add(correction);
     947                 :            :         correction = pps_phase_filter_get(&jitter);
     948                 :            : 
     949                 :            :         /* Nominal jitter is due to PPS signal noise. If it exceeds the
     950                 :            :          * threshold, the sample is discarded; otherwise, if so enabled,
     951                 :            :          * the time offset is updated.
     952                 :            :          */
     953                 :            :         if (jitter > (pps_jitter << PPS_POPCORN)) {
     954                 :            :                 printk_deferred(KERN_WARNING
     955                 :            :                                 "hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
     956                 :            :                                 jitter, (pps_jitter << PPS_POPCORN));
     957                 :            :                 time_status |= STA_PPSJITTER;
     958                 :            :                 pps_jitcnt++;
     959                 :            :         } else if (time_status & STA_PPSTIME) {
     960                 :            :                 /* correct the time using the phase offset */
     961                 :            :                 time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
     962                 :            :                                 NTP_INTERVAL_FREQ);
     963                 :            :                 /* cancel running adjtime() */
     964                 :            :                 time_adjust = 0;
     965                 :            :         }
     966                 :            :         /* update jitter */
     967                 :            :         pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
     968                 :            : }
     969                 :            : 
     970                 :            : /*
     971                 :            :  * __hardpps() - discipline CPU clock oscillator to external PPS signal
     972                 :            :  *
     973                 :            :  * This routine is called at each PPS signal arrival in order to
     974                 :            :  * discipline the CPU clock oscillator to the PPS signal. It takes two
     975                 :            :  * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former
     976                 :            :  * is used to correct clock phase error and the latter is used to
     977                 :            :  * correct the frequency.
     978                 :            :  *
     979                 :            :  * This code is based on David Mills's reference nanokernel
     980                 :            :  * implementation. It was mostly rewritten but keeps the same idea.
     981                 :            :  */
     982                 :            : void __hardpps(const struct timespec64 *phase_ts, const struct timespec64 *raw_ts)
     983                 :            : {
     984                 :            :         struct pps_normtime pts_norm, freq_norm;
     985                 :            : 
     986                 :            :         pts_norm = pps_normalize_ts(*phase_ts);
     987                 :            : 
     988                 :            :         /* clear the error bits, they will be set again if needed */
     989                 :            :         time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
     990                 :            : 
     991                 :            :         /* indicate signal presence */
     992                 :            :         time_status |= STA_PPSSIGNAL;
     993                 :            :         pps_valid = PPS_VALID;
     994                 :            : 
     995                 :            :         /* when called for the first time,
     996                 :            :          * just start the frequency interval */
     997                 :            :         if (unlikely(pps_fbase.tv_sec == 0)) {
     998                 :            :                 pps_fbase = *raw_ts;
     999                 :            :                 return;
    1000                 :            :         }
    1001                 :            : 
    1002                 :            :         /* ok, now we have a base for frequency calculation */
    1003                 :            :         freq_norm = pps_normalize_ts(timespec64_sub(*raw_ts, pps_fbase));
    1004                 :            : 
    1005                 :            :         /* check that the signal is in the range
    1006                 :            :          * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
    1007                 :            :         if ((freq_norm.sec == 0) ||
    1008                 :            :                         (freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
    1009                 :            :                         (freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
    1010                 :            :                 time_status |= STA_PPSJITTER;
    1011                 :            :                 /* restart the frequency calibration interval */
    1012                 :            :                 pps_fbase = *raw_ts;
    1013                 :            :                 printk_deferred(KERN_ERR "hardpps: PPSJITTER: bad pulse\n");
    1014                 :            :                 return;
    1015                 :            :         }
    1016                 :            : 
    1017                 :            :         /* signal is ok */
    1018                 :            : 
    1019                 :            :         /* check if the current frequency interval is finished */
    1020                 :            :         if (freq_norm.sec >= (1 << pps_shift)) {
    1021                 :            :                 pps_calcnt++;
    1022                 :            :                 /* restart the frequency calibration interval */
    1023                 :            :                 pps_fbase = *raw_ts;
    1024                 :            :                 hardpps_update_freq(freq_norm);
    1025                 :            :         }
    1026                 :            : 
    1027                 :            :         hardpps_update_phase(pts_norm.nsec);
    1028                 :            : 
    1029                 :            : }
    1030                 :            : #endif  /* CONFIG_NTP_PPS */
    1031                 :            : 
    1032                 :          0 : static int __init ntp_tick_adj_setup(char *str)
    1033                 :            : {
    1034                 :            :         int rc = kstrtos64(str, 0, &ntp_tick_adj);
    1035                 :          0 :         if (rc)
    1036                 :            :                 return rc;
    1037                 :            : 
    1038                 :          0 :         ntp_tick_adj <<= NTP_SCALE_SHIFT;
    1039                 :          0 :         return 1;
    1040                 :            : }
    1041                 :            : 
    1042                 :            : __setup("ntp_tick_adj=", ntp_tick_adj_setup);
    1043                 :            : 
    1044                 :          3 : void __init ntp_init(void)
    1045                 :            : {
    1046                 :          3 :         ntp_clear();
    1047                 :          3 : }
    

Generated by: LCOV version 1.14