ptp: Switch to ktime_get_snapshot_id() for pre/post timestamps

To prepare for a new PTP IOCTL, which exposes the raw counter value along
with the requested system time snapshot, switch the pre/post time stamp
sampling over to use ktime_get_snapshot_id() and fix up all usage sites.

No functional change intended.

The ptp_vmclock conversion was simplified by David Woodhouse.

Signed-off-by: Thomas Gleixner <tglx@kernel.org>
Tested-by: David Woodhouse <dwmw@amazon.co.uk>
Tested-by: Arthur Kiyanovski <akiyano@amazon.com>
Reviewed-by: David Woodhouse <dwmw@amazon.co.uk>
Reviewed-by: Jacob Keller <jacob.e.keller@intel.com>
Acked-by: Vadim Fedorenko <vadim.fedorenko@linux.dev>
Link: https://patch.msgid.link/20260529195558.149589566@kernel.org

diff --git a/drivers/net/dsa/sja1105/sja1105_main.c b/drivers/net/dsa/sja1105/sja1105_main.c
index c72c2bfdcffb2e6ff3d05fd951c457c6f0e06638..2697073dbf900edf96992036d087a119e489635b 100644 (file)
--- a/drivers/net/dsa/sja1105/sja1105_main.c
+++ b/drivers/net/dsa/sja1105/sja1105_main.c
@@ -2310,10 +2310,10 @@ int sja1105_static_config_reload(struct sja1105_private *priv,
                goto out;
        }
 
-       t1 = timespec64_to_ns(&ptp_sts_before.pre_ts);
-       t2 = timespec64_to_ns(&ptp_sts_before.post_ts);
-       t3 = timespec64_to_ns(&ptp_sts_after.pre_ts);
-       t4 = timespec64_to_ns(&ptp_sts_after.post_ts);
+       t1 = ktime_to_ns(ptp_sts_before.pre_sts.systime);
+       t2 = ktime_to_ns(ptp_sts_before.post_sts.systime);
+       t3 = ktime_to_ns(ptp_sts_after.pre_sts.systime);
+       t4 = ktime_to_ns(ptp_sts_after.post_sts.systime);
        /* Mid point, corresponds to pre-reset PTPCLKVAL */
        t12 = t1 + (t2 - t1) / 2;
        /* Mid point, corresponds to post-reset PTPCLKVAL, aka 0 */

diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c
index f52bbb39cd8bacea53af3347d8a91498faf54a7a..dc23cd708cfec2bfa96e89e4fe82e073e2285445 100644 (file)
--- a/drivers/ptp/ptp_chardev.c
+++ b/drivers/ptp/ptp_chardev.c
@@ -386,15 +386,19 @@ static long ptp_sys_offset_extended(struct ptp_clock *ptp, void __user *arg,
                        return err;
 
                /* Filter out disabled or unavailable clocks */
-               if (sts.pre_ts.tv_sec < 0 || sts.post_ts.tv_sec < 0)
+               if (!sts.pre_sts.valid || !sts.post_sts.valid)
                        return -EINVAL;
 
-               extoff->ts[i][0].sec = sts.pre_ts.tv_sec;
-               extoff->ts[i][0].nsec = sts.pre_ts.tv_nsec;
                extoff->ts[i][1].sec = ts.tv_sec;
                extoff->ts[i][1].nsec = ts.tv_nsec;
-               extoff->ts[i][2].sec = sts.post_ts.tv_sec;
-               extoff->ts[i][2].nsec = sts.post_ts.tv_nsec;
+
+               ts = ktime_to_timespec64(sts.pre_sts.systime);
+               extoff->ts[i][0].sec = ts.tv_sec;
+               extoff->ts[i][0].nsec = ts.tv_nsec;
+
+               ts = ktime_to_timespec64(sts.post_sts.systime);
+               extoff->ts[i][2].sec = ts.tv_sec;
+               extoff->ts[i][2].nsec = ts.tv_nsec;
        }
 
        return copy_to_user(arg, extoff, sizeof(*extoff)) ? -EFAULT : 0;

diff --git a/drivers/ptp/ptp_ocp.c b/drivers/ptp/ptp_ocp.c
index beacc2ffb166b315df7559952f1d3a012b9fc958..28b0302c6250b3b8bcce5d9b51153abe26f40290 100644 (file)
--- a/drivers/ptp/ptp_ocp.c
+++ b/drivers/ptp/ptp_ocp.c
@@ -1491,11 +1491,8 @@ __ptp_ocp_gettime_locked(struct ptp_ocp *bp, struct timespec64 *ts,
        }
        ptp_read_system_postts(sts);
 
-       if (sts && bp->ts_window_adjust) {
-               s64 ns = timespec64_to_ns(&sts->post_ts);
-
-               sts->post_ts = ns_to_timespec64(ns - bp->ts_window_adjust);
-       }
+       if (sts && bp->ts_window_adjust)
+               sts->post_sts.systime -= bp->ts_window_adjust;
 
        time_ns = ioread32(&bp->reg->time_ns);
        time_sec = ioread32(&bp->reg->time_sec);
@@ -4595,8 +4592,8 @@ ptp_ocp_summary_show(struct seq_file *s, void *data)
                struct timespec64 sys_ts;
                s64 pre_ns, post_ns, ns;
 
-               pre_ns = timespec64_to_ns(&sts.pre_ts);
-               post_ns = timespec64_to_ns(&sts.post_ts);
+               pre_ns = ktime_to_ns(sts.pre_sts.systime);
+               post_ns = ktime_to_ns(sts.post_sts.systime);
                ns = (pre_ns + post_ns) / 2;
                ns += (s64)bp->utc_tai_offset * NSEC_PER_SEC;
                sys_ts = ns_to_timespec64(ns);

diff --git a/drivers/ptp/ptp_vmclock.c b/drivers/ptp/ptp_vmclock.c
index 0f12b54be740ea2fe74ad171145f27fff5d72a2a..d6a5a533164aafb43f05c5dab9512c256738adc2 100644 (file)
--- a/drivers/ptp/ptp_vmclock.c
+++ b/drivers/ptp/ptp_vmclock.c
@@ -101,7 +101,6 @@ static int vmclock_get_crosststamp(struct vmclock_state *st,
                                   struct timespec64 *tspec)
 {
        ktime_t deadline = ktime_add(ktime_get(), VMCLOCK_MAX_WAIT);
-       struct system_time_snapshot systime_snapshot;
        uint64_t cycle, delta, seq, frac_sec;
 
 #ifdef CONFIG_X86
@@ -132,17 +131,15 @@ static int vmclock_get_crosststamp(struct vmclock_state *st,
                 * will be derived from the *same* counter value.
                 *
                 * If the system isn't using the same counter, then the value
-                * from ktime_get_snapshot_id() will still be used as pre_ts, and
-                * ptp_read_system_postts() is called to populate postts after
-                * calling get_cycles().
-                *
-                * The conversion to timespec64 happens further down, outside
-                * the seq_count loop.
+                * from ptp_read_system_prets() will still be used as pre_ts,
+                * and ptp_read_system_postts() is called to populate postts
+                * after calling get_cycles().
                 */
                if (sts) {
-                       ktime_get_snapshot_id(CLOCK_REALTIME, &systime_snapshot);
-                       if (systime_snapshot.cs_id == st->cs_id) {
-                               cycle = systime_snapshot.cycles;
+                       ptp_read_system_prets(sts);
+                       if (sts->pre_sts.cs_id == st->cs_id) {
+                               cycle = sts->pre_sts.cycles;
+                               sts->post_sts = sts->pre_sts;
                        } else {
                                cycle = get_cycles();
                                ptp_read_system_postts(sts);
@@ -180,12 +177,6 @@ static int vmclock_get_crosststamp(struct vmclock_state *st,
                system_counter->cs_id = st->cs_id;
        }
 
-       if (sts) {
-               sts->pre_ts = ktime_to_timespec64(systime_snapshot.systime);
-               if (systime_snapshot.cs_id == st->cs_id)
-                       sts->post_ts = sts->pre_ts;
-       }
-
        return 0;
 }
 

diff --git a/include/linux/ptp_clock_kernel.h b/include/linux/ptp_clock_kernel.h
index 884364596dd32493e6fcb42a52432610567d3858..36a27a91059587ce6129b4b50a321675643006d8 100644 (file)
--- a/include/linux/ptp_clock_kernel.h
+++ b/include/linux/ptp_clock_kernel.h
@@ -12,6 +12,7 @@
 #include <linux/pps_kernel.h>
 #include <linux/ptp_clock.h>
 #include <linux/timecounter.h>
+#include <linux/timekeeping.h>
 #include <linux/skbuff.h>
 
 #define PTP_CLOCK_NAME_LEN     32
@@ -45,13 +46,13 @@ struct system_device_crosststamp;
 
 /**
  * struct ptp_system_timestamp - system time corresponding to a PHC timestamp
- * @pre_ts: system timestamp before capturing PHC
- * @post_ts: system timestamp after capturing PHC
- * @clockid: clock-base used for capturing the system timestamps
+ * @pre_sts:   system time snapshot before capturing PHC
+ * @post_sts:  system time snapshot after capturing PHC
+ * @clockid:   clock-base used for capturing the system timestamps
  */
 struct ptp_system_timestamp {
-       struct timespec64 pre_ts;
-       struct timespec64 post_ts;
+       struct system_time_snapshot pre_sts;
+       struct system_time_snapshot post_sts;
        clockid_t clockid;
 };
 
@@ -510,13 +511,13 @@ static inline ktime_t ptp_convert_timestamp(const ktime_t *hwtstamp,
 static inline void ptp_read_system_prets(struct ptp_system_timestamp *sts)
 {
        if (sts)
-               ktime_get_clock_ts64(sts->clockid, &sts->pre_ts);
+               ktime_get_snapshot_id(sts->clockid, &sts->pre_sts);
 }
 
 static inline void ptp_read_system_postts(struct ptp_system_timestamp *sts)
 {
        if (sts)
-               ktime_get_clock_ts64(sts->clockid, &sts->post_ts);
+               ktime_get_snapshot_id(sts->clockid, &sts->post_sts);
 }
 
 #endif