1ktime accessors
2===============
3
4Device drivers can read the current time using ktime_get() and the many
5related functions declared in linux/timekeeping.h. As a rule of thumb,
6using an accessor with a shorter name is preferred over one with a longer
7name if both are equally fit for a particular use case.
8
9Basic ktime_t based interfaces
10------------------------------
11
12The recommended simplest form returns an opaque ktime_t, with variants
13that return time for different clock references:
14
15
16.. c:function:: ktime_t ktime_get( void )
17
18	CLOCK_MONOTONIC
19
20	Useful for reliable timestamps and measuring short time intervals
21	accurately. Starts at system boot time but stops during suspend.
22
23.. c:function:: ktime_t ktime_get_boottime( void )
24
25	CLOCK_BOOTTIME
26
27	Like ktime_get(), but does not stop when suspended. This can be
28	used e.g. for key expiration times that need to be synchronized
29	with other machines across a suspend operation.
30
31.. c:function:: ktime_t ktime_get_real( void )
32
33	CLOCK_REALTIME
34
35	Returns the time in relative to the UNIX epoch starting in 1970
36	using the Coordinated Universal Time (UTC), same as gettimeofday()
37	user space. This is used for all timestamps that need to
38	persist across a reboot, like inode times, but should be avoided
39	for internal uses, since it can jump backwards due to a leap
40	second update, NTP adjustment settimeofday() operation from user
41	space.
42
43.. c:function:: ktime_t ktime_get_clocktai( void )
44
45	 CLOCK_TAI
46
47	Like ktime_get_real(), but uses the International Atomic Time (TAI)
48	reference instead of UTC to avoid jumping on leap second updates.
49	This is rarely useful in the kernel.
50
51.. c:function:: ktime_t ktime_get_raw( void )
52
53	CLOCK_MONOTONIC_RAW
54
55	Like ktime_get(), but runs at the same rate as the hardware
56	clocksource without (NTP) adjustments for clock drift. This is
57	also rarely needed in the kernel.
58
59nanosecond, timespec64, and second output
60-----------------------------------------
61
62For all of the above, there are variants that return the time in a
63different format depending on what is required by the user:
64
65.. c:function:: u64 ktime_get_ns( void )
66		u64 ktime_get_boottime_ns( void )
67		u64 ktime_get_real_ns( void )
68		u64 ktime_get_clocktai_ns( void )
69		u64 ktime_get_raw_ns( void )
70
71	Same as the plain ktime_get functions, but returning a u64 number
72	of nanoseconds in the respective time reference, which may be
73	more convenient for some callers.
74
75.. c:function:: void ktime_get_ts64( struct timespec64 * )
76		void ktime_get_boottime_ts64( struct timespec64 * )
77		void ktime_get_real_ts64( struct timespec64 * )
78		void ktime_get_clocktai_ts64( struct timespec64 * )
79		void ktime_get_raw_ts64( struct timespec64 * )
80
81	Same above, but returns the time in a 'struct timespec64', split
82	into seconds and nanoseconds. This can avoid an extra division
83	when printing the time, or when passing it into an external
84	interface that expects a 'timespec' or 'timeval' structure.
85
86.. c:function:: time64_t ktime_get_seconds( void )
87		time64_t ktime_get_boottime_seconds( void )
88		time64_t ktime_get_real_seconds( void )
89		time64_t ktime_get_clocktai_seconds( void )
90		time64_t ktime_get_raw_seconds( void )
91
92	Return a coarse-grained version of the time as a scalar
93	time64_t. This avoids accessing the clock hardware and rounds
94	down the seconds to the full seconds of the last timer tick
95	using the respective reference.
96
97Coarse and fast_ns access
98-------------------------
99
100Some additional variants exist for more specialized cases:
101
102.. c:function:: ktime_t ktime_get_coarse( void )
103		ktime_t ktime_get_coarse_boottime( void )
104		ktime_t ktime_get_coarse_real( void )
105		ktime_t ktime_get_coarse_clocktai( void )
106
107.. c:function:: u64 ktime_get_coarse_ns( void )
108		u64 ktime_get_coarse_boottime_ns( void )
109		u64 ktime_get_coarse_real_ns( void )
110		u64 ktime_get_coarse_clocktai_ns( void )
111
112.. c:function:: void ktime_get_coarse_ts64( struct timespec64 * )
113		void ktime_get_coarse_boottime_ts64( struct timespec64 * )
114		void ktime_get_coarse_real_ts64( struct timespec64 * )
115		void ktime_get_coarse_clocktai_ts64( struct timespec64 * )
116
117	These are quicker than the non-coarse versions, but less accurate,
118	corresponding to CLOCK_MONOTONIC_COARSE and CLOCK_REALTIME_COARSE
119	in user space, along with the equivalent boottime/tai/raw
120	timebase not available in user space.
121
122	The time returned here corresponds to the last timer tick, which
123	may be as much as 10ms in the past (for CONFIG_HZ=100), same as
124	reading the 'jiffies' variable.  These are only useful when called
125	in a fast path and one still expects better than second accuracy,
126	but can't easily use 'jiffies', e.g. for inode timestamps.
127	Skipping the hardware clock access saves around 100 CPU cycles
128	on most modern machines with a reliable cycle counter, but
129	up to several microseconds on older hardware with an external
130	clocksource.
131
132.. c:function:: u64 ktime_get_mono_fast_ns( void )
133		u64 ktime_get_raw_fast_ns( void )
134		u64 ktime_get_boot_fast_ns( void )
135		u64 ktime_get_real_fast_ns( void )
136
137	These variants are safe to call from any context, including from
138	a non-maskable interrupt (NMI) during a timekeeper update, and
139	while we are entering suspend with the clocksource powered down.
140	This is useful in some tracing or debugging code as well as
141	machine check reporting, but most drivers should never call them,
142	since the time is allowed to jump under certain conditions.
143
144Deprecated time interfaces
145--------------------------
146
147Older kernels used some other interfaces that are now being phased out
148but may appear in third-party drivers being ported here. In particular,
149all interfaces returning a 'struct timeval' or 'struct timespec' have
150been replaced because the tv_sec member overflows in year 2038 on 32-bit
151architectures. These are the recommended replacements:
152
153.. c:function:: void ktime_get_ts( struct timespec * )
154
155	Use ktime_get() or ktime_get_ts64() instead.
156
157.. c:function:: struct timeval do_gettimeofday( void )
158		struct timespec getnstimeofday( void )
159		struct timespec64 getnstimeofday64( void )
160		void ktime_get_real_ts( struct timespec * )
161
162	ktime_get_real_ts64() is a direct replacement, but consider using
163	monotonic time (ktime_get_ts64()) and/or a ktime_t based interface
164	(ktime_get()/ktime_get_real()).
165
166.. c:function:: struct timespec current_kernel_time( void )
167		struct timespec64 current_kernel_time64( void )
168		struct timespec get_monotonic_coarse( void )
169		struct timespec64 get_monotonic_coarse64( void )
170
171	These are replaced by ktime_get_coarse_real_ts64() and
172	ktime_get_coarse_ts64(). However, A lot of code that wants
173	coarse-grained times can use the simple 'jiffies' instead, while
174	some drivers may actually want the higher resolution accessors
175	these days.
176
177.. c:function:: struct timespec getrawmonotonic( void )
178		struct timespec64 getrawmonotonic64( void )
179		struct timespec timekeeping_clocktai( void )
180		struct timespec64 timekeeping_clocktai64( void )
181		struct timespec get_monotonic_boottime( void )
182		struct timespec64 get_monotonic_boottime64( void )
183
184	These are replaced by ktime_get_raw()/ktime_get_raw_ts64(),
185	ktime_get_clocktai()/ktime_get_clocktai_ts64() as well
186	as ktime_get_boottime()/ktime_get_boottime_ts64().
187	However, if the particular choice of clock source is not
188	important for the user, consider converting to
189	ktime_get()/ktime_get_ts64() instead for consistency.
190