ntp: Add timekeeper ID arguments to public functions

In preparation for supporting auxiliary POSIX clocks, add a timekeeper ID
to the relevant functions.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: John Stultz <jstultz@google.com>
Link: https://lore.kernel.org/all/20250519083026.032425931@linutronix.de

diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 5b5a0f76866d23db3b86b3b4bc9d4dae6e3f5abf..e28dc53194a72af295416740addd3e45b1b50c84 100644 (file)
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -351,33 +351,38 @@ static void __ntp_clear(struct ntp_data *ntpdata)
 
 /**
  * ntp_clear - Clears the NTP state variables
+ * @tkid:      Timekeeper ID to be able to select proper ntp data array member
  */
-void ntp_clear(void)
+void ntp_clear(unsigned int tkid)
 {
-       __ntp_clear(&tk_ntp_data[TIMEKEEPER_CORE]);
+       __ntp_clear(&tk_ntp_data[tkid]);
 }
 
 
-u64 ntp_tick_length(void)
+u64 ntp_tick_length(unsigned int tkid)
 {
-       return tk_ntp_data[TIMEKEEPER_CORE].tick_length;
+       return tk_ntp_data[tkid].tick_length;
 }
 
 /**
  * ntp_get_next_leap - Returns the next leapsecond in CLOCK_REALTIME ktime_t
+ * @tkid:      Timekeeper ID
  *
- * Provides the time of the next leapsecond against CLOCK_REALTIME in
- * a ktime_t format. Returns KTIME_MAX if no leapsecond is pending.
+ * Returns: For @tkid == TIMEKEEPER_CORE this provides the time of the next
+ *         leap second against CLOCK_REALTIME in a ktime_t format if a
+ *         leap second is pending. KTIME_MAX otherwise.
  */
-ktime_t ntp_get_next_leap(void)
+ktime_t ntp_get_next_leap(unsigned int tkid)
 {
        struct ntp_data *ntpdata = &tk_ntp_data[TIMEKEEPER_CORE];
-       ktime_t ret;
+
+       if (tkid != TIMEKEEPER_CORE)
+               return KTIME_MAX;
 
        if ((ntpdata->time_state == TIME_INS) && (ntpdata->time_status & STA_INS))
                return ktime_set(ntpdata->ntp_next_leap_sec, 0);
-       ret = KTIME_MAX;
-       return ret;
+
+       return KTIME_MAX;
 }
 
 /*
@@ -390,9 +395,9 @@ ktime_t ntp_get_next_leap(void)
  *
  * Also handles leap second processing, and returns leap offset
  */
-int second_overflow(time64_t secs)
+int second_overflow(unsigned int tkid, time64_t secs)
 {
-       struct ntp_data *ntpdata = &tk_ntp_data[TIMEKEEPER_CORE];
+       struct ntp_data *ntpdata = &tk_ntp_data[tkid];
        s64 delta;
        int leap = 0;
        s32 rem;
@@ -762,10 +767,10 @@ static inline void process_adjtimex_modes(struct ntp_data *ntpdata, const struct
  * adjtimex() mainly allows reading (and writing, if superuser) of
  * kernel time-keeping variables. used by xntpd.
  */
-int __do_adjtimex(struct __kernel_timex *txc, const struct timespec64 *ts,
+int __do_adjtimex(unsigned int tkid, struct __kernel_timex *txc, const struct timespec64 *ts,
                  s32 *time_tai, struct audit_ntp_data *ad)
 {
-       struct ntp_data *ntpdata = &tk_ntp_data[TIMEKEEPER_CORE];
+       struct ntp_data *ntpdata = &tk_ntp_data[tkid];
        int result;
 
        if (txc->modes & ADJ_ADJTIME) {

diff --git a/kernel/time/ntp_internal.h b/kernel/time/ntp_internal.h
index 5a633dce9057aa866878a2b51c1f86a766140117..2d3e9669730b01c791f1cbfeb63935e7464f9c90 100644 (file)
--- a/kernel/time/ntp_internal.h
+++ b/kernel/time/ntp_internal.h
@@ -3,13 +3,12 @@
 #define _LINUX_NTP_INTERNAL_H
 
 extern void ntp_init(void);
-extern void ntp_clear(void);
+extern void ntp_clear(unsigned int tkid);
 /* Returns how long ticks are at present, in ns / 2^NTP_SCALE_SHIFT. */
-extern u64 ntp_tick_length(void);
-extern ktime_t ntp_get_next_leap(void);
-extern int second_overflow(time64_t secs);
-extern int __do_adjtimex(struct __kernel_timex *txc,
-                        const struct timespec64 *ts,
+extern u64 ntp_tick_length(unsigned int tkid);
+extern ktime_t ntp_get_next_leap(unsigned int tkid);
+extern int second_overflow(unsigned int tkid, time64_t secs);
+extern int __do_adjtimex(unsigned int tkid, struct __kernel_timex *txc, const struct timespec64 *ts,
                         s32 *time_tai, struct audit_ntp_data *ad);
 extern void __hardpps(const struct timespec64 *phase_ts, const struct timespec64 *raw_ts);
 

diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index f4692fc2ea6b5913fc76a6cac7c6ff820fa92a6d..e1b8e2618ca7d16cc98b18e506e0640dac056e31 100644 (file)
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -601,7 +601,7 @@ EXPORT_SYMBOL_GPL(pvclock_gtod_unregister_notifier);
  */
 static inline void tk_update_leap_state(struct timekeeper *tk)
 {
-       tk->next_leap_ktime = ntp_get_next_leap();
+       tk->next_leap_ktime = ntp_get_next_leap(tk->id);
        if (tk->next_leap_ktime != KTIME_MAX)
                /* Convert to monotonic time */
                tk->next_leap_ktime = ktime_sub(tk->next_leap_ktime, tk->offs_real);
@@ -678,7 +678,7 @@ static void timekeeping_update_from_shadow(struct tk_data *tkd, unsigned int act
 
        if (action & TK_CLEAR_NTP) {
                tk->ntp_error = 0;
-               ntp_clear();
+               ntp_clear(tk->id);
        }
 
        tk_update_leap_state(tk);
@@ -2049,7 +2049,7 @@ static __always_inline void timekeeping_apply_adjustment(struct timekeeper *tk,
  */
 static void timekeeping_adjust(struct timekeeper *tk, s64 offset)
 {
-       u64 ntp_tl = ntp_tick_length();
+       u64 ntp_tl = ntp_tick_length(tk->id);
        u32 mult;
 
        /*
@@ -2130,7 +2130,7 @@ static inline unsigned int accumulate_nsecs_to_secs(struct timekeeper *tk)
                }
 
                /* Figure out if its a leap sec and apply if needed */
-               leap = second_overflow(tk->xtime_sec);
+               leap = second_overflow(tk->id, tk->xtime_sec);
                if (unlikely(leap)) {
                        struct timespec64 ts;
 
@@ -2227,7 +2227,7 @@ static bool __timekeeping_advance(enum timekeeping_adv_mode mode)
        shift = ilog2(offset) - ilog2(tk->cycle_interval);
        shift = max(0, shift);
        /* Bound shift to one less than what overflows tick_length */
-       maxshift = (64 - (ilog2(ntp_tick_length())+1)) - 1;
+       maxshift = (64 - (ilog2(ntp_tick_length(tk->id)) + 1)) - 1;
        shift = min(shift, maxshift);
        while (offset >= tk->cycle_interval) {
                offset = logarithmic_accumulation(tk, offset, shift, &clock_set);
@@ -2586,7 +2586,7 @@ int do_adjtimex(struct __kernel_timex *txc)
                }
 
                orig_tai = tai = tks->tai_offset;
-               ret = __do_adjtimex(txc, &ts, &tai, &ad);
+               ret = __do_adjtimex(tks->id, txc, &ts, &tai, &ad);
 
                if (tai != orig_tai) {
                        __timekeeping_set_tai_offset(tks, tai);