1 /* 2 * include/linux/ktime.h 3 * 4 * ktime_t - nanosecond-resolution time format. 5 * 6 * Copyright(C) 2005, Thomas Gleixner <[email protected]> 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 /* 28 * ktime_t: 29 * 30 * A single 64-bit variable is used to store the hrtimers 31 * internal representation of time values in scalar nanoseconds. The 32 * design plays out best on 64-bit CPUs, where most conversions are 33 * NOPs and most arithmetic ktime_t operations are plain arithmetic 34 * operations. 35 * 36 */ 37 union ktime { 38 s64 tv64; 39 }; 40 41 typedef union ktime ktime_t; /* Kill this */ 42 43 /** 44 * ktime_set - Set a ktime_t variable from a seconds/nanoseconds value 45 * @secs: seconds to set 46 * @nsecs: nanoseconds to set 47 * 48 * Return: The ktime_t representation of the value. 49 */ 50 static inline ktime_t ktime_set(const long secs, const unsigned long nsecs) 51 { 52 #if (BITS_PER_LONG == 64) 53 if (unlikely(secs >= KTIME_SEC_MAX)) 54 return (ktime_t){ .tv64 = KTIME_MAX }; 55 #endif 56 return (ktime_t) { .tv64 = (s64)secs * NSEC_PER_SEC + (s64)nsecs }; 57 } 58 59 /* Subtract two ktime_t variables. rem = lhs -rhs: */ 60 #define ktime_sub(lhs, rhs) \ 61 ({ (ktime_t){ .tv64 = (lhs).tv64 - (rhs).tv64 }; }) 62 63 /* Add two ktime_t variables. res = lhs + rhs: */ 64 #define ktime_add(lhs, rhs) \ 65 ({ (ktime_t){ .tv64 = (lhs).tv64 + (rhs).tv64 }; }) 66 67 /* 68 * Add a ktime_t variable and a scalar nanosecond value. 69 * res = kt + nsval: 70 */ 71 #define ktime_add_ns(kt, nsval) \ 72 ({ (ktime_t){ .tv64 = (kt).tv64 + (nsval) }; }) 73 74 /* 75 * Subtract a scalar nanosecod from a ktime_t variable 76 * res = kt - nsval: 77 */ 78 #define ktime_sub_ns(kt, nsval) \ 79 ({ (ktime_t){ .tv64 = (kt).tv64 - (nsval) }; }) 80 81 /* convert a timespec to ktime_t format: */ 82 static inline ktime_t timespec_to_ktime(struct timespec ts) 83 { 84 return ktime_set(ts.tv_sec, ts.tv_nsec); 85 } 86 87 /* convert a timeval to ktime_t format: */ 88 static inline ktime_t timeval_to_ktime(struct timeval tv) 89 { 90 return ktime_set(tv.tv_sec, tv.tv_usec * NSEC_PER_USEC); 91 } 92 93 /* Map the ktime_t to timespec conversion to ns_to_timespec function */ 94 #define ktime_to_timespec(kt) ns_to_timespec((kt).tv64) 95 96 /* Map the ktime_t to timeval conversion to ns_to_timeval function */ 97 #define ktime_to_timeval(kt) ns_to_timeval((kt).tv64) 98 99 /* Convert ktime_t to nanoseconds - NOP in the scalar storage format: */ 100 #define ktime_to_ns(kt) ((kt).tv64) 101 102 103 /** 104 * ktime_equal - Compares two ktime_t variables to see if they are equal 105 * @cmp1: comparable1 106 * @cmp2: comparable2 107 * 108 * Compare two ktime_t variables. 109 * 110 * Return: 1 if equal. 111 */ 112 static inline int ktime_equal(const ktime_t cmp1, const ktime_t cmp2) 113 { 114 return cmp1.tv64 == cmp2.tv64; 115 } 116 117 /** 118 * ktime_compare - Compares two ktime_t variables for less, greater or equal 119 * @cmp1: comparable1 120 * @cmp2: comparable2 121 * 122 * Return: ... 123 * cmp1 < cmp2: return <0 124 * cmp1 == cmp2: return 0 125 * cmp1 > cmp2: return >0 126 */ 127 static inline int ktime_compare(const ktime_t cmp1, const ktime_t cmp2) 128 { 129 if (cmp1.tv64 < cmp2.tv64) 130 return -1; 131 if (cmp1.tv64 > cmp2.tv64) 132 return 1; 133 return 0; 134 } 135 136 /** 137 * ktime_after - Compare if a ktime_t value is bigger than another one. 138 * @cmp1: comparable1 139 * @cmp2: comparable2 140 * 141 * Return: true if cmp1 happened after cmp2. 142 */ 143 static inline bool ktime_after(const ktime_t cmp1, const ktime_t cmp2) 144 { 145 return ktime_compare(cmp1, cmp2) > 0; 146 } 147 148 /** 149 * ktime_before - Compare if a ktime_t value is smaller than another one. 150 * @cmp1: comparable1 151 * @cmp2: comparable2 152 * 153 * Return: true if cmp1 happened before cmp2. 154 */ 155 static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2) 156 { 157 return ktime_compare(cmp1, cmp2) < 0; 158 } 159 160 #if BITS_PER_LONG < 64 161 extern u64 ktime_divns(const ktime_t kt, s64 div); 162 #else /* BITS_PER_LONG < 64 */ 163 # define ktime_divns(kt, div) (u64)((kt).tv64 / (div)) 164 #endif 165 166 static inline s64 ktime_to_us(const ktime_t kt) 167 { 168 return ktime_divns(kt, NSEC_PER_USEC); 169 } 170 171 static inline s64 ktime_to_ms(const ktime_t kt) 172 { 173 return ktime_divns(kt, NSEC_PER_MSEC); 174 } 175 176 static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier) 177 { 178 return ktime_to_us(ktime_sub(later, earlier)); 179 } 180 181 static inline ktime_t ktime_add_us(const ktime_t kt, const u64 usec) 182 { 183 return ktime_add_ns(kt, usec * NSEC_PER_USEC); 184 } 185 186 static inline ktime_t ktime_add_ms(const ktime_t kt, const u64 msec) 187 { 188 return ktime_add_ns(kt, msec * NSEC_PER_MSEC); 189 } 190 191 static inline ktime_t ktime_sub_us(const ktime_t kt, const u64 usec) 192 { 193 return ktime_sub_ns(kt, usec * NSEC_PER_USEC); 194 } 195 196 extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs); 197 198 /** 199 * ktime_to_timespec_cond - convert a ktime_t variable to timespec 200 * format only if the variable contains data 201 * @kt: the ktime_t variable to convert 202 * @ts: the timespec variable to store the result in 203 * 204 * Return: %true if there was a successful conversion, %false if kt was 0. 205 */ 206 static inline __must_check bool ktime_to_timespec_cond(const ktime_t kt, 207 struct timespec *ts) 208 { 209 if (kt.tv64) { 210 *ts = ktime_to_timespec(kt); 211 return true; 212 } else { 213 return false; 214 } 215 } 216 217 /* 218 * The resolution of the clocks. The resolution value is returned in 219 * the clock_getres() system call to give application programmers an 220 * idea of the (in)accuracy of timers. Timer values are rounded up to 221 * this resolution values. 222 */ 223 #define LOW_RES_NSEC TICK_NSEC 224 #define KTIME_LOW_RES (ktime_t){ .tv64 = LOW_RES_NSEC } 225 226 /* Get the monotonic time in timespec format: */ 227 extern void ktime_get_ts(struct timespec *ts); 228 229 /* Get the real (wall-) time in timespec format: */ 230 #define ktime_get_real_ts(ts) getnstimeofday(ts) 231 232 static inline ktime_t ns_to_ktime(u64 ns) 233 { 234 static const ktime_t ktime_zero = { .tv64 = 0 }; 235 236 return ktime_add_ns(ktime_zero, ns); 237 } 238 239 static inline ktime_t ms_to_ktime(u64 ms) 240 { 241 static const ktime_t ktime_zero = { .tv64 = 0 }; 242 243 return ktime_add_ms(ktime_zero, ms); 244 } 245 246 #endif 247