1/*
  2 * You SHOULD NOT be including this unless you're vsyscall
  3 * handling code or timekeeping internal code!
  4 */
  5
  6#ifndef _LINUX_TIMEKEEPER_INTERNAL_H
  7#define _LINUX_TIMEKEEPER_INTERNAL_H
  8
  9#include <linux/clocksource.h>
 10#include <linux/jiffies.h>
 11#include <linux/time.h>
 12
 13/**
 14 * struct tk_read_base - base structure for timekeeping readout
 15 * @clock:	Current clocksource used for timekeeping.
 16 * @read:	Read function of @clock
 17 * @mask:	Bitmask for two's complement subtraction of non 64bit clocks
 18 * @cycle_last: @clock cycle value at last update
 19 * @mult:	(NTP adjusted) multiplier for scaled math conversion
 20 * @shift:	Shift value for scaled math conversion
 21 * @xtime_nsec: Shifted (fractional) nano seconds offset for readout
 22 * @base:	ktime_t (nanoseconds) base time for readout
 23 *
 24 * This struct has size 56 byte on 64 bit. Together with a seqcount it
 25 * occupies a single 64byte cache line.
 26 *
 27 * The struct is separate from struct timekeeper as it is also used
 28 * for a fast NMI safe accessors.
 29 */
 30struct tk_read_base {
 31	struct clocksource	*clock;
 32	u64			(*read)(struct clocksource *cs);
 33	u64			mask;
 34	u64			cycle_last;
 35	u32			mult;
 
 36	u32			shift;
 37	u64			xtime_nsec;
 38	ktime_t			base;
 39};
 40
 41/**
 42 * struct timekeeper - Structure holding internal timekeeping values.
 43 * @tkr_mono:		The readout base structure for CLOCK_MONOTONIC
 44 * @tkr_raw:		The readout base structure for CLOCK_MONOTONIC_RAW
 45 * @xtime_sec:		Current CLOCK_REALTIME time in seconds
 46 * @ktime_sec:		Current CLOCK_MONOTONIC time in seconds
 47 * @wall_to_monotonic:	CLOCK_REALTIME to CLOCK_MONOTONIC offset
 48 * @offs_real:		Offset clock monotonic -> clock realtime
 49 * @offs_boot:		Offset clock monotonic -> clock boottime
 50 * @offs_tai:		Offset clock monotonic -> clock tai
 51 * @tai_offset:		The current UTC to TAI offset in seconds
 52 * @clock_was_set_seq:	The sequence number of clock was set events
 53 * @cs_was_changed_seq:	The sequence number of clocksource change events
 54 * @next_leap_ktime:	CLOCK_MONOTONIC time value of a pending leap-second
 55 * @raw_time:		Monotonic raw base time in timespec64 format
 56 * @cycle_interval:	Number of clock cycles in one NTP interval
 57 * @xtime_interval:	Number of clock shifted nano seconds in one NTP
 58 *			interval.
 59 * @xtime_remainder:	Shifted nano seconds left over when rounding
 60 *			@cycle_interval
 61 * @raw_interval:	Raw nano seconds accumulated per NTP interval.
 62 * @ntp_error:		Difference between accumulated time and NTP time in ntp
 63 *			shifted nano seconds.
 64 * @ntp_error_shift:	Shift conversion between clock shifted nano seconds and
 65 *			ntp shifted nano seconds.
 66 * @last_warning:	Warning ratelimiter (DEBUG_TIMEKEEPING)
 67 * @underflow_seen:	Underflow warning flag (DEBUG_TIMEKEEPING)
 68 * @overflow_seen:	Overflow warning flag (DEBUG_TIMEKEEPING)
 69 *
 70 * Note: For timespec(64) based interfaces wall_to_monotonic is what
 71 * we need to add to xtime (or xtime corrected for sub jiffie times)
 72 * to get to monotonic time.  Monotonic is pegged at zero at system
 73 * boot time, so wall_to_monotonic will be negative, however, we will
 74 * ALWAYS keep the tv_nsec part positive so we can use the usual
 75 * normalization.
 76 *
 77 * wall_to_monotonic is moved after resume from suspend for the
 78 * monotonic time not to jump. We need to add total_sleep_time to
 79 * wall_to_monotonic to get the real boot based time offset.
 80 *
 81 * wall_to_monotonic is no longer the boot time, getboottime must be
 82 * used instead.
 83 */
 84struct timekeeper {
 85	struct tk_read_base	tkr_mono;
 86	struct tk_read_base	tkr_raw;
 87	u64			xtime_sec;
 88	unsigned long		ktime_sec;
 89	struct timespec64	wall_to_monotonic;
 90	ktime_t			offs_real;
 91	ktime_t			offs_boot;
 92	ktime_t			offs_tai;
 93	s32			tai_offset;
 94	unsigned int		clock_was_set_seq;
 95	u8			cs_was_changed_seq;
 96	ktime_t			next_leap_ktime;
 97	struct timespec64	raw_time;
 98
 99	/* The following members are for timekeeping internal use */
100	u64			cycle_interval;
101	u64			xtime_interval;
 
102	s64			xtime_remainder;
 
103	u32			raw_interval;
104	/* The ntp_tick_length() value currently being used.
105	 * This cached copy ensures we consistently apply the tick
106	 * length for an entire tick, as ntp_tick_length may change
107	 * mid-tick, and we don't want to apply that new value to
108	 * the tick in progress.
109	 */
110	u64			ntp_tick;
111	/* Difference between accumulated time and NTP time in ntp
112	 * shifted nano seconds. */
113	s64			ntp_error;
 
 
114	u32			ntp_error_shift;
115	u32			ntp_err_mult;
116#ifdef CONFIG_DEBUG_TIMEKEEPING
117	long			last_warning;
118	/*
119	 * These simple flag variables are managed
120	 * without locks, which is racy, but they are
121	 * ok since we don't really care about being
122	 * super precise about how many events were
123	 * seen, just that a problem was observed.
 
 
 
 
 
 
 
124	 */
125	int			underflow_seen;
126	int			overflow_seen;
127#endif
 
 
 
 
 
 
 
 
 
 
 
128};
129
 
 
 
 
 
 
 
 
 
 
130#ifdef CONFIG_GENERIC_TIME_VSYSCALL
131
132extern void update_vsyscall(struct timekeeper *tk);
133extern void update_vsyscall_tz(void);
134
135#elif defined(CONFIG_GENERIC_TIME_VSYSCALL_OLD)
136
137extern void update_vsyscall_old(struct timespec *ts, struct timespec *wtm,
138				struct clocksource *c, u32 mult,
139				u64 cycle_last);
140extern void update_vsyscall_tz(void);
 
 
 
 
 
 
 
 
141
142#else
143
144static inline void update_vsyscall(struct timekeeper *tk)
145{
146}
147static inline void update_vsyscall_tz(void)
148{
149}
150#endif
151
152#endif /* _LINUX_TIMEKEEPER_INTERNAL_H */

  1/*
  2 * You SHOULD NOT be including this unless you're vsyscall
  3 * handling code or timekeeping internal code!
  4 */
  5
  6#ifndef _LINUX_TIMEKEEPER_INTERNAL_H
  7#define _LINUX_TIMEKEEPER_INTERNAL_H
  8
  9#include <linux/clocksource.h>
 10#include <linux/jiffies.h>
 11#include <linux/time.h>
 12
 13/* Structure holding internal timekeeping values. */
 14struct timekeeper {
 15	/* Current clocksource used for timekeeping. */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 16	struct clocksource	*clock;
 17	/* NTP adjusted clock multiplier */
 
 
 18	u32			mult;
 19	/* The shift value of the current clocksource. */
 20	u32			shift;
 21	/* Number of clock cycles in one NTP interval. */
 22	cycle_t			cycle_interval;
 23	/* Last cycle value (also stored in clock->cycle_last) */
 24	cycle_t			cycle_last;
 25	/* Number of clock shifted nano seconds in one NTP interval. */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 26	u64			xtime_interval;
 27	/* shifted nano seconds left over when rounding cycle_interval */
 28	s64			xtime_remainder;
 29	/* Raw nano seconds accumulated per NTP interval. */
 30	u32			raw_interval;
 31
 32	/* Current CLOCK_REALTIME time in seconds */
 33	u64			xtime_sec;
 34	/* Clock shifted nano seconds */
 35	u64			xtime_nsec;
 36
 
 37	/* Difference between accumulated time and NTP time in ntp
 38	 * shifted nano seconds. */
 39	s64			ntp_error;
 40	/* Shift conversion between clock shifted nano seconds and
 41	 * ntp shifted nano seconds. */
 42	u32			ntp_error_shift;
 43
 
 
 44	/*
 45	 * wall_to_monotonic is what we need to add to xtime (or xtime corrected
 46	 * for sub jiffie times) to get to monotonic time.  Monotonic is pegged
 47	 * at zero at system boot time, so wall_to_monotonic will be negative,
 48	 * however, we will ALWAYS keep the tv_nsec part positive so we can use
 49	 * the usual normalization.
 50	 *
 51	 * wall_to_monotonic is moved after resume from suspend for the
 52	 * monotonic time not to jump. We need to add total_sleep_time to
 53	 * wall_to_monotonic to get the real boot based time offset.
 54	 *
 55	 * - wall_to_monotonic is no longer the boot time, getboottime must be
 56	 * used instead.
 57	 */
 58	struct timespec		wall_to_monotonic;
 59	/* Offset clock monotonic -> clock realtime */
 60	ktime_t			offs_real;
 61	/* time spent in suspend */
 62	struct timespec		total_sleep_time;
 63	/* Offset clock monotonic -> clock boottime */
 64	ktime_t			offs_boot;
 65	/* The raw monotonic time for the CLOCK_MONOTONIC_RAW posix clock. */
 66	struct timespec		raw_time;
 67	/* The current UTC to TAI offset in seconds */
 68	s32			tai_offset;
 69	/* Offset clock monotonic -> clock tai */
 70	ktime_t			offs_tai;
 71
 72};
 73
 74static inline struct timespec tk_xtime(struct timekeeper *tk)
 75{
 76	struct timespec ts;
 77
 78	ts.tv_sec = tk->xtime_sec;
 79	ts.tv_nsec = (long)(tk->xtime_nsec >> tk->shift);
 80	return ts;
 81}
 82
 83
 84#ifdef CONFIG_GENERIC_TIME_VSYSCALL
 85
 86extern void update_vsyscall(struct timekeeper *tk);
 87extern void update_vsyscall_tz(void);
 88
 89#elif defined(CONFIG_GENERIC_TIME_VSYSCALL_OLD)
 90
 91extern void update_vsyscall_old(struct timespec *ts, struct timespec *wtm,
 92				struct clocksource *c, u32 mult);
 
 93extern void update_vsyscall_tz(void);
 94
 95static inline void update_vsyscall(struct timekeeper *tk)
 96{
 97	struct timespec xt;
 98
 99	xt = tk_xtime(tk);
100	update_vsyscall_old(&xt, &tk->wall_to_monotonic, tk->clock, tk->mult);
101}
102
103#else
104
105static inline void update_vsyscall(struct timekeeper *tk)
106{
107}
108static inline void update_vsyscall_tz(void)
109{
110}
111#endif
112
113#endif /* _LINUX_TIMEKEEPER_INTERNAL_H */