]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - include/linux/ktime.h
ktime: Get rid of the union
[karo-tx-linux.git] / include / linux / ktime.h
1 /*
2  *  include/linux/ktime.h
3  *
4  *  ktime_t - nanosecond-resolution time format.
5  *
6  *   Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
7  *   Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
8  *
9  *  data type definitions, declarations, prototypes and macros.
10  *
11  *  Started by: Thomas Gleixner and Ingo Molnar
12  *
13  *  Credits:
14  *
15  *      Roman Zippel provided the ideas and primary code snippets of
16  *      the ktime_t union and further simplifications of the original
17  *      code.
18  *
19  *  For licencing details see kernel-base/COPYING
20  */
21 #ifndef _LINUX_KTIME_H
22 #define _LINUX_KTIME_H
23
24 #include <linux/time.h>
25 #include <linux/jiffies.h>
26
27 /* Nanosecond scalar representation for kernel time values */
28 typedef s64     ktime_t;
29
30 /**
31  * ktime_set - Set a ktime_t variable from a seconds/nanoseconds value
32  * @secs:       seconds to set
33  * @nsecs:      nanoseconds to set
34  *
35  * Return: The ktime_t representation of the value.
36  */
37 static inline ktime_t ktime_set(const s64 secs, const unsigned long nsecs)
38 {
39         if (unlikely(secs >= KTIME_SEC_MAX))
40                 return KTIME_MAX;
41
42         return secs * NSEC_PER_SEC + (s64)nsecs;
43 }
44
45 /* Subtract two ktime_t variables. rem = lhs -rhs: */
46 #define ktime_sub(lhs, rhs)     ((lhs) - (rhs))
47
48 /* Add two ktime_t variables. res = lhs + rhs: */
49 #define ktime_add(lhs, rhs)     ((lhs) + (rhs))
50
51 /*
52  * Same as ktime_add(), but avoids undefined behaviour on overflow; however,
53  * this means that you must check the result for overflow yourself.
54  */
55 #define ktime_add_unsafe(lhs, rhs)      ((u64) (lhs) + (rhs))
56
57 /*
58  * Add a ktime_t variable and a scalar nanosecond value.
59  * res = kt + nsval:
60  */
61 #define ktime_add_ns(kt, nsval)         ((kt) + (nsval))
62
63 /*
64  * Subtract a scalar nanosecod from a ktime_t variable
65  * res = kt - nsval:
66  */
67 #define ktime_sub_ns(kt, nsval)         ((kt) - (nsval))
68
69 /* convert a timespec to ktime_t format: */
70 static inline ktime_t timespec_to_ktime(struct timespec ts)
71 {
72         return ktime_set(ts.tv_sec, ts.tv_nsec);
73 }
74
75 /* convert a timespec64 to ktime_t format: */
76 static inline ktime_t timespec64_to_ktime(struct timespec64 ts)
77 {
78         return ktime_set(ts.tv_sec, ts.tv_nsec);
79 }
80
81 /* convert a timeval to ktime_t format: */
82 static inline ktime_t timeval_to_ktime(struct timeval tv)
83 {
84         return ktime_set(tv.tv_sec, tv.tv_usec * NSEC_PER_USEC);
85 }
86
87 /* Map the ktime_t to timespec conversion to ns_to_timespec function */
88 #define ktime_to_timespec(kt)           ns_to_timespec((kt))
89
90 /* Map the ktime_t to timespec conversion to ns_to_timespec function */
91 #define ktime_to_timespec64(kt)         ns_to_timespec64((kt))
92
93 /* Map the ktime_t to timeval conversion to ns_to_timeval function */
94 #define ktime_to_timeval(kt)            ns_to_timeval((kt))
95
96 /* Convert ktime_t to nanoseconds - NOP in the scalar storage format: */
97 #define ktime_to_ns(kt)                 (kt)
98
99
100 /**
101  * ktime_equal - Compares two ktime_t variables to see if they are equal
102  * @cmp1:       comparable1
103  * @cmp2:       comparable2
104  *
105  * Compare two ktime_t variables.
106  *
107  * Return: 1 if equal.
108  */
109 static inline int ktime_equal(const ktime_t cmp1, const ktime_t cmp2)
110 {
111         return cmp1 == cmp2;
112 }
113
114 /**
115  * ktime_compare - Compares two ktime_t variables for less, greater or equal
116  * @cmp1:       comparable1
117  * @cmp2:       comparable2
118  *
119  * Return: ...
120  *   cmp1  < cmp2: return <0
121  *   cmp1 == cmp2: return 0
122  *   cmp1  > cmp2: return >0
123  */
124 static inline int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
125 {
126         if (cmp1 < cmp2)
127                 return -1;
128         if (cmp1 > cmp2)
129                 return 1;
130         return 0;
131 }
132
133 /**
134  * ktime_after - Compare if a ktime_t value is bigger than another one.
135  * @cmp1:       comparable1
136  * @cmp2:       comparable2
137  *
138  * Return: true if cmp1 happened after cmp2.
139  */
140 static inline bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)
141 {
142         return ktime_compare(cmp1, cmp2) > 0;
143 }
144
145 /**
146  * ktime_before - Compare if a ktime_t value is smaller than another one.
147  * @cmp1:       comparable1
148  * @cmp2:       comparable2
149  *
150  * Return: true if cmp1 happened before cmp2.
151  */
152 static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
153 {
154         return ktime_compare(cmp1, cmp2) < 0;
155 }
156
157 #if BITS_PER_LONG < 64
158 extern s64 __ktime_divns(const ktime_t kt, s64 div);
159 static inline s64 ktime_divns(const ktime_t kt, s64 div)
160 {
161         /*
162          * Negative divisors could cause an inf loop,
163          * so bug out here.
164          */
165         BUG_ON(div < 0);
166         if (__builtin_constant_p(div) && !(div >> 32)) {
167                 s64 ns = kt;
168                 u64 tmp = ns < 0 ? -ns : ns;
169
170                 do_div(tmp, div);
171                 return ns < 0 ? -tmp : tmp;
172         } else {
173                 return __ktime_divns(kt, div);
174         }
175 }
176 #else /* BITS_PER_LONG < 64 */
177 static inline s64 ktime_divns(const ktime_t kt, s64 div)
178 {
179         /*
180          * 32-bit implementation cannot handle negative divisors,
181          * so catch them on 64bit as well.
182          */
183         WARN_ON(div < 0);
184         return kt / div;
185 }
186 #endif
187
188 static inline s64 ktime_to_us(const ktime_t kt)
189 {
190         return ktime_divns(kt, NSEC_PER_USEC);
191 }
192
193 static inline s64 ktime_to_ms(const ktime_t kt)
194 {
195         return ktime_divns(kt, NSEC_PER_MSEC);
196 }
197
198 static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
199 {
200        return ktime_to_us(ktime_sub(later, earlier));
201 }
202
203 static inline s64 ktime_ms_delta(const ktime_t later, const ktime_t earlier)
204 {
205         return ktime_to_ms(ktime_sub(later, earlier));
206 }
207
208 static inline ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
209 {
210         return ktime_add_ns(kt, usec * NSEC_PER_USEC);
211 }
212
213 static inline ktime_t ktime_add_ms(const ktime_t kt, const u64 msec)
214 {
215         return ktime_add_ns(kt, msec * NSEC_PER_MSEC);
216 }
217
218 static inline ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
219 {
220         return ktime_sub_ns(kt, usec * NSEC_PER_USEC);
221 }
222
223 static inline ktime_t ktime_sub_ms(const ktime_t kt, const u64 msec)
224 {
225         return ktime_sub_ns(kt, msec * NSEC_PER_MSEC);
226 }
227
228 extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);
229
230 /**
231  * ktime_to_timespec_cond - convert a ktime_t variable to timespec
232  *                          format only if the variable contains data
233  * @kt:         the ktime_t variable to convert
234  * @ts:         the timespec variable to store the result in
235  *
236  * Return: %true if there was a successful conversion, %false if kt was 0.
237  */
238 static inline __must_check bool ktime_to_timespec_cond(const ktime_t kt,
239                                                        struct timespec *ts)
240 {
241         if (kt) {
242                 *ts = ktime_to_timespec(kt);
243                 return true;
244         } else {
245                 return false;
246         }
247 }
248
249 /**
250  * ktime_to_timespec64_cond - convert a ktime_t variable to timespec64
251  *                          format only if the variable contains data
252  * @kt:         the ktime_t variable to convert
253  * @ts:         the timespec variable to store the result in
254  *
255  * Return: %true if there was a successful conversion, %false if kt was 0.
256  */
257 static inline __must_check bool ktime_to_timespec64_cond(const ktime_t kt,
258                                                        struct timespec64 *ts)
259 {
260         if (kt) {
261                 *ts = ktime_to_timespec64(kt);
262                 return true;
263         } else {
264                 return false;
265         }
266 }
267
268 /*
269  * The resolution of the clocks. The resolution value is returned in
270  * the clock_getres() system call to give application programmers an
271  * idea of the (in)accuracy of timers. Timer values are rounded up to
272  * this resolution values.
273  */
274 #define LOW_RES_NSEC            TICK_NSEC
275 #define KTIME_LOW_RES           (LOW_RES_NSEC)
276
277 static inline ktime_t ns_to_ktime(u64 ns)
278 {
279         return ns;
280 }
281
282 static inline ktime_t ms_to_ktime(u64 ms)
283 {
284         return ms * NSEC_PER_MSEC;
285 }
286
287 # include <linux/timekeeping.h>
288
289 #endif