timekeeping.h 8.11 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
2 3 4
#ifndef _LINUX_TIMEKEEPING_H
#define _LINUX_TIMEKEEPING_H

5
#include <linux/errno.h>
6

7 8 9 10 11
/* Included from linux/ktime.h */

void timekeeping_init(void);
extern int timekeeping_suspended;

12 13 14 15
/* Architecture timer tick functions: */
extern void update_process_times(int user);
extern void xtime_update(unsigned long ticks);

16 17 18 19
/*
 * Get and set timeofday
 */
extern void do_gettimeofday(struct timeval *tv);
20
extern int do_settimeofday64(const struct timespec64 *ts);
21 22
extern int do_sys_settimeofday64(const struct timespec64 *tv,
				 const struct timezone *tz);
23 24 25 26
/*
 * Kernel time accessors
 */
unsigned long get_seconds(void);
27
struct timespec64 current_kernel_time64(void);
28 29 30
/* does not take xtime_lock */
struct timespec __current_kernel_time(void);

31 32 33 34 35 36 37
static inline struct timespec current_kernel_time(void)
{
	struct timespec64 now = current_kernel_time64();

	return timespec64_to_timespec(now);
}

38 39 40
/*
 * timespec based interfaces
 */
41
struct timespec64 get_monotonic_coarse64(void);
42
extern void getrawmonotonic64(struct timespec64 *ts);
43
extern void ktime_get_ts64(struct timespec64 *ts);
44
extern time64_t ktime_get_seconds(void);
45
extern time64_t ktime_get_real_seconds(void);
46 47 48

extern int __getnstimeofday64(struct timespec64 *tv);
extern void getnstimeofday64(struct timespec64 *tv);
49
extern void getboottime64(struct timespec64 *ts);
50 51

#if BITS_PER_LONG == 64
52 53 54 55 56 57 58 59
/**
 * Deprecated. Use do_settimeofday64().
 */
static inline int do_settimeofday(const struct timespec *ts)
{
	return do_settimeofday64(ts);
}

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
static inline int __getnstimeofday(struct timespec *ts)
{
	return __getnstimeofday64(ts);
}

static inline void getnstimeofday(struct timespec *ts)
{
	getnstimeofday64(ts);
}

static inline void ktime_get_ts(struct timespec *ts)
{
	ktime_get_ts64(ts);
}

static inline void ktime_get_real_ts(struct timespec *ts)
{
	getnstimeofday64(ts);
}

80 81 82 83 84
static inline void getrawmonotonic(struct timespec *ts)
{
	getrawmonotonic64(ts);
}

85 86 87 88
static inline struct timespec get_monotonic_coarse(void)
{
	return get_monotonic_coarse64();
}
89 90 91 92 93

static inline void getboottime(struct timespec *ts)
{
	return getboottime64(ts);
}
94
#else
95 96 97 98 99 100 101 102 103 104 105
/**
 * Deprecated. Use do_settimeofday64().
 */
static inline int do_settimeofday(const struct timespec *ts)
{
	struct timespec64 ts64;

	ts64 = timespec_to_timespec64(*ts);
	return do_settimeofday64(&ts64);
}

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
static inline int __getnstimeofday(struct timespec *ts)
{
	struct timespec64 ts64;
	int ret = __getnstimeofday64(&ts64);

	*ts = timespec64_to_timespec(ts64);
	return ret;
}

static inline void getnstimeofday(struct timespec *ts)
{
	struct timespec64 ts64;

	getnstimeofday64(&ts64);
	*ts = timespec64_to_timespec(ts64);
}

static inline void ktime_get_ts(struct timespec *ts)
{
	struct timespec64 ts64;

	ktime_get_ts64(&ts64);
	*ts = timespec64_to_timespec(ts64);
}

static inline void ktime_get_real_ts(struct timespec *ts)
{
	struct timespec64 ts64;

	getnstimeofday64(&ts64);
	*ts = timespec64_to_timespec(ts64);
}
138 139 140 141 142 143 144 145

static inline void getrawmonotonic(struct timespec *ts)
{
	struct timespec64 ts64;

	getrawmonotonic64(&ts64);
	*ts = timespec64_to_timespec(ts64);
}
146 147 148 149 150

static inline struct timespec get_monotonic_coarse(void)
{
	return timespec64_to_timespec(get_monotonic_coarse64());
}
151

152 153 154 155 156 157 158 159
static inline void getboottime(struct timespec *ts)
{
	struct timespec64 ts64;

	getboottime64(&ts64);
	*ts = timespec64_to_timespec(ts64);
}
#endif
160

161
#define ktime_get_real_ts64(ts)	getnstimeofday64(ts)
162 163 164 165

/*
 * ktime_t based interfaces
 */
166 167 168 169 170 171 172 173

enum tk_offsets {
	TK_OFFS_REAL,
	TK_OFFS_BOOT,
	TK_OFFS_TAI,
	TK_OFFS_MAX,
};

174
extern ktime_t ktime_get(void);
175
extern ktime_t ktime_get_with_offset(enum tk_offsets offs);
176
extern ktime_t ktime_mono_to_any(ktime_t tmono, enum tk_offsets offs);
177
extern ktime_t ktime_get_raw(void);
178
extern u32 ktime_get_resolution_ns(void);
179

180 181 182 183 184 185 186 187
/**
 * ktime_get_real - get the real (wall-) time in ktime_t format
 */
static inline ktime_t ktime_get_real(void)
{
	return ktime_get_with_offset(TK_OFFS_REAL);
}

188 189 190 191 192 193 194 195 196 197 198
/**
 * ktime_get_boottime - Returns monotonic time since boot in ktime_t format
 *
 * This is similar to CLOCK_MONTONIC/ktime_get, but also includes the
 * time spent in suspend.
 */
static inline ktime_t ktime_get_boottime(void)
{
	return ktime_get_with_offset(TK_OFFS_BOOT);
}

199 200 201 202 203 204 205 206
/**
 * ktime_get_clocktai - Returns the TAI time of day in ktime_t format
 */
static inline ktime_t ktime_get_clocktai(void)
{
	return ktime_get_with_offset(TK_OFFS_TAI);
}

207 208 209 210 211 212 213 214
/**
 * ktime_mono_to_real - Convert monotonic time to clock realtime
 */
static inline ktime_t ktime_mono_to_real(ktime_t mono)
{
	return ktime_mono_to_any(mono, TK_OFFS_REAL);
}

215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
static inline u64 ktime_get_ns(void)
{
	return ktime_to_ns(ktime_get());
}

static inline u64 ktime_get_real_ns(void)
{
	return ktime_to_ns(ktime_get_real());
}

static inline u64 ktime_get_boot_ns(void)
{
	return ktime_to_ns(ktime_get_boottime());
}

230 231 232 233 234
static inline u64 ktime_get_tai_ns(void)
{
	return ktime_to_ns(ktime_get_clocktai());
}

235 236 237 238 239
static inline u64 ktime_get_raw_ns(void)
{
	return ktime_to_ns(ktime_get_raw());
}

240
extern u64 ktime_get_mono_fast_ns(void);
Peter Zijlstra's avatar
Peter Zijlstra committed
241
extern u64 ktime_get_raw_fast_ns(void);
242
extern u64 ktime_get_boot_fast_ns(void);
243

244 245 246 247 248 249 250 251
/*
 * Timespec interfaces utilizing the ktime based ones
 */
static inline void get_monotonic_boottime(struct timespec *ts)
{
	*ts = ktime_to_timespec(ktime_get_boottime());
}

252 253 254 255 256
static inline void get_monotonic_boottime64(struct timespec64 *ts)
{
	*ts = ktime_to_timespec64(ktime_get_boottime());
}

257 258 259 260 261
static inline void timekeeping_clocktai(struct timespec *ts)
{
	*ts = ktime_to_timespec(ktime_get_clocktai());
}

262 263 264 265 266
static inline void timekeeping_clocktai64(struct timespec64 *ts)
{
	*ts = ktime_to_timespec64(ktime_get_clocktai());
}

267 268 269
/*
 * RTC specific
 */
270 271 272
extern bool timekeeping_rtc_skipsuspend(void);
extern bool timekeeping_rtc_skipresume(void);

273 274
extern void timekeeping_inject_sleeptime64(struct timespec64 *delta);

275 276 277
/*
 * PPS accessor
 */
278 279
extern void ktime_get_raw_and_real_ts64(struct timespec64 *ts_raw,
				        struct timespec64 *ts_real);
280

281 282 283 284 285 286
/*
 * struct system_time_snapshot - simultaneous raw/real time capture with
 *	counter value
 * @cycles:	Clocksource counter value to produce the system times
 * @real:	Realtime system time
 * @raw:	Monotonic raw system time
287 288
 * @clock_was_set_seq:	The sequence number of clock was set events
 * @cs_was_changed_seq:	The sequence number of clocksource change events
289 290
 */
struct system_time_snapshot {
291
	u64		cycles;
292 293
	ktime_t		real;
	ktime_t		raw;
294 295
	unsigned int	clock_was_set_seq;
	u8		cs_was_changed_seq;
296 297
};

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
/*
 * struct system_device_crosststamp - system/device cross-timestamp
 *	(syncronized capture)
 * @device:		Device time
 * @sys_realtime:	Realtime simultaneous with device time
 * @sys_monoraw:	Monotonic raw simultaneous with device time
 */
struct system_device_crosststamp {
	ktime_t device;
	ktime_t sys_realtime;
	ktime_t sys_monoraw;
};

/*
 * struct system_counterval_t - system counter value with the pointer to the
 *	corresponding clocksource
 * @cycles:	System counter value
 * @cs:		Clocksource corresponding to system counter value. Used by
 *	timekeeping code to verify comparibility of two cycle values
 */
struct system_counterval_t {
319
	u64			cycles;
320 321 322 323 324 325 326 327 328 329 330
	struct clocksource	*cs;
};

/*
 * Get cross timestamp between system clock and device clock
 */
extern int get_device_system_crosststamp(
			int (*get_time_fn)(ktime_t *device_time,
				struct system_counterval_t *system_counterval,
				void *ctx),
			void *ctx,
331
			struct system_time_snapshot *history,
332 333
			struct system_device_crosststamp *xtstamp);

334 335 336 337 338
/*
 * Simultaneously snapshot realtime and monotonic raw clocks
 */
extern void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot);

339 340 341 342 343 344
/*
 * Persistent clock related interfaces
 */
extern int persistent_clock_is_local;

extern void read_persistent_clock(struct timespec *ts);
345
extern void read_persistent_clock64(struct timespec64 *ts);
346
extern void read_boot_clock64(struct timespec64 *ts);
347
extern int update_persistent_clock(struct timespec now);
348
extern int update_persistent_clock64(struct timespec64 now);
349

350 351 352 353 354 355 356 357
#ifdef CONFIG_IPIPE
void update_root_process_times(struct pt_regs *regs);
#else  /* !CONFIG_IPIPE */
static inline void update_root_process_times(struct pt_regs *regs)
{
	update_process_times(user_mode(regs));
}
#endif /* CONFIG_IPIPE */
358 359

#endif