jiffies.h 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #ifndef _LINUX_JIFFIES_H
  3. #define _LINUX_JIFFIES_H
  4. #include <linux/cache.h>
  5. #include <linux/limits.h>
  6. #include <linux/math64.h>
  7. #include <linux/minmax.h>
  8. #include <linux/types.h>
  9. #include <linux/time.h>
  10. #include <linux/timex.h>
  11. #include <vdso/jiffies.h>
  12. #include <asm/param.h> /* for HZ */
  13. #include <generated/timeconst.h>
  14. /*
  15. * The following defines establish the engineering parameters of the PLL
  16. * model. The HZ variable establishes the timer interrupt frequency, 100 Hz
  17. * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the
  18. * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the
  19. * nearest power of two in order to avoid hardware multiply operations.
  20. */
  21. #if HZ >= 12 && HZ < 24
  22. # define SHIFT_HZ 4
  23. #elif HZ >= 24 && HZ < 48
  24. # define SHIFT_HZ 5
  25. #elif HZ >= 48 && HZ < 96
  26. # define SHIFT_HZ 6
  27. #elif HZ >= 96 && HZ < 192
  28. # define SHIFT_HZ 7
  29. #elif HZ >= 192 && HZ < 384
  30. # define SHIFT_HZ 8
  31. #elif HZ >= 384 && HZ < 768
  32. # define SHIFT_HZ 9
  33. #elif HZ >= 768 && HZ < 1536
  34. # define SHIFT_HZ 10
  35. #elif HZ >= 1536 && HZ < 3072
  36. # define SHIFT_HZ 11
  37. #elif HZ >= 3072 && HZ < 6144
  38. # define SHIFT_HZ 12
  39. #elif HZ >= 6144 && HZ < 12288
  40. # define SHIFT_HZ 13
  41. #else
  42. # error Invalid value of HZ.
  43. #endif
  44. /* Suppose we want to divide two numbers NOM and DEN: NOM/DEN, then we can
  45. * improve accuracy by shifting LSH bits, hence calculating:
  46. * (NOM << LSH) / DEN
  47. * This however means trouble for large NOM, because (NOM << LSH) may no
  48. * longer fit in 32 bits. The following way of calculating this gives us
  49. * some slack, under the following conditions:
  50. * - (NOM / DEN) fits in (32 - LSH) bits.
  51. * - (NOM % DEN) fits in (32 - LSH) bits.
  52. */
  53. #define SH_DIV(NOM,DEN,LSH) ( (((NOM) / (DEN)) << (LSH)) \
  54. + ((((NOM) % (DEN)) << (LSH)) + (DEN) / 2) / (DEN))
  55. /* LATCH is used in the interval timer and ftape setup. */
  56. #define LATCH ((CLOCK_TICK_RATE + HZ/2) / HZ) /* For divider */
  57. extern int register_refined_jiffies(long clock_tick_rate);
  58. /* TICK_USEC is the time between ticks in usec assuming SHIFTED_HZ */
  59. #define TICK_USEC ((USEC_PER_SEC + HZ/2) / HZ)
  60. /* USER_TICK_USEC is the time between ticks in usec assuming fake USER_HZ */
  61. #define USER_TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ)
  62. #ifndef __jiffy_arch_data
  63. #define __jiffy_arch_data
  64. #endif
  65. /*
  66. * The 64-bit value is not atomic - you MUST NOT read it
  67. * without sampling the sequence number in jiffies_lock.
  68. * get_jiffies_64() will do this for you as appropriate.
  69. */
  70. extern u64 __cacheline_aligned_in_smp jiffies_64;
  71. extern unsigned long volatile __cacheline_aligned_in_smp __jiffy_arch_data jiffies;
  72. #if (BITS_PER_LONG < 64)
  73. u64 get_jiffies_64(void);
  74. #else
  75. static inline u64 get_jiffies_64(void)
  76. {
  77. return (u64)jiffies;
  78. }
  79. #endif
  80. /*
  81. * These inlines deal with timer wrapping correctly. You are
  82. * strongly encouraged to use them
  83. * 1. Because people otherwise forget
  84. * 2. Because if the timer wrap changes in future you won't have to
  85. * alter your driver code.
  86. *
  87. * time_after(a,b) returns true if the time a is after time b.
  88. *
  89. * Do this with "<0" and ">=0" to only test the sign of the result. A
  90. * good compiler would generate better code (and a really good compiler
  91. * wouldn't care). Gcc is currently neither.
  92. */
  93. #define time_after(a,b) \
  94. (typecheck(unsigned long, a) && \
  95. typecheck(unsigned long, b) && \
  96. ((long)((b) - (a)) < 0))
  97. #define time_before(a,b) time_after(b,a)
  98. #define time_after_eq(a,b) \
  99. (typecheck(unsigned long, a) && \
  100. typecheck(unsigned long, b) && \
  101. ((long)((a) - (b)) >= 0))
  102. #define time_before_eq(a,b) time_after_eq(b,a)
  103. /*
  104. * Calculate whether a is in the range of [b, c].
  105. */
  106. #define time_in_range(a,b,c) \
  107. (time_after_eq(a,b) && \
  108. time_before_eq(a,c))
  109. /*
  110. * Calculate whether a is in the range of [b, c).
  111. */
  112. #define time_in_range_open(a,b,c) \
  113. (time_after_eq(a,b) && \
  114. time_before(a,c))
  115. /* Same as above, but does so with platform independent 64bit types.
  116. * These must be used when utilizing jiffies_64 (i.e. return value of
  117. * get_jiffies_64() */
  118. #define time_after64(a,b) \
  119. (typecheck(__u64, a) && \
  120. typecheck(__u64, b) && \
  121. ((__s64)((b) - (a)) < 0))
  122. #define time_before64(a,b) time_after64(b,a)
  123. #define time_after_eq64(a,b) \
  124. (typecheck(__u64, a) && \
  125. typecheck(__u64, b) && \
  126. ((__s64)((a) - (b)) >= 0))
  127. #define time_before_eq64(a,b) time_after_eq64(b,a)
  128. #define time_in_range64(a, b, c) \
  129. (time_after_eq64(a, b) && \
  130. time_before_eq64(a, c))
  131. /*
  132. * These four macros compare jiffies and 'a' for convenience.
  133. */
  134. /* time_is_before_jiffies(a) return true if a is before jiffies */
  135. #define time_is_before_jiffies(a) time_after(jiffies, a)
  136. #define time_is_before_jiffies64(a) time_after64(get_jiffies_64(), a)
  137. /* time_is_after_jiffies(a) return true if a is after jiffies */
  138. #define time_is_after_jiffies(a) time_before(jiffies, a)
  139. #define time_is_after_jiffies64(a) time_before64(get_jiffies_64(), a)
  140. /* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/
  141. #define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a)
  142. #define time_is_before_eq_jiffies64(a) time_after_eq64(get_jiffies_64(), a)
  143. /* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/
  144. #define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a)
  145. #define time_is_after_eq_jiffies64(a) time_before_eq64(get_jiffies_64(), a)
  146. /*
  147. * Have the 32 bit jiffies value wrap 5 minutes after boot
  148. * so jiffies wrap bugs show up earlier.
  149. */
  150. #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  151. /*
  152. * Change timeval to jiffies, trying to avoid the
  153. * most obvious overflows..
  154. *
  155. * And some not so obvious.
  156. *
  157. * Note that we don't want to return LONG_MAX, because
  158. * for various timeout reasons we often end up having
  159. * to wait "jiffies+1" in order to guarantee that we wait
  160. * at _least_ "jiffies" - so "jiffies+1" had better still
  161. * be positive.
  162. */
  163. #define MAX_JIFFY_OFFSET ((LONG_MAX >> 1)-1)
  164. extern unsigned long preset_lpj;
  165. /*
  166. * We want to do realistic conversions of time so we need to use the same
  167. * values the update wall clock code uses as the jiffies size. This value
  168. * is: TICK_NSEC (which is defined in timex.h). This
  169. * is a constant and is in nanoseconds. We will use scaled math
  170. * with a set of scales defined here as SEC_JIFFIE_SC, USEC_JIFFIE_SC and
  171. * NSEC_JIFFIE_SC. Note that these defines contain nothing but
  172. * constants and so are computed at compile time. SHIFT_HZ (computed in
  173. * timex.h) adjusts the scaling for different HZ values.
  174. * Scaled math??? What is that?
  175. *
  176. * Scaled math is a way to do integer math on values that would,
  177. * otherwise, either overflow, underflow, or cause undesired div
  178. * instructions to appear in the execution path. In short, we "scale"
  179. * up the operands so they take more bits (more precision, less
  180. * underflow), do the desired operation and then "scale" the result back
  181. * by the same amount. If we do the scaling by shifting we avoid the
  182. * costly mpy and the dastardly div instructions.
  183. * Suppose, for example, we want to convert from seconds to jiffies
  184. * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE. The
  185. * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We
  186. * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we
  187. * might calculate at compile time, however, the result will only have
  188. * about 3-4 bits of precision (less for smaller values of HZ).
  189. *
  190. * So, we scale as follows:
  191. * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE);
  192. * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE;
  193. * Then we make SCALE a power of two so:
  194. * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE;
  195. * Now we define:
  196. * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE))
  197. * jiff = (sec * SEC_CONV) >> SCALE;
  198. *
  199. * Often the math we use will expand beyond 32-bits so we tell C how to
  200. * do this and pass the 64-bit result of the mpy through the ">> SCALE"
  201. * which should take the result back to 32-bits. We want this expansion
  202. * to capture as much precision as possible. At the same time we don't
  203. * want to overflow so we pick the SCALE to avoid this. In this file,
  204. * that means using a different scale for each range of HZ values (as
  205. * defined in timex.h).
  206. *
  207. * For those who want to know, gcc will give a 64-bit result from a "*"
  208. * operator if the result is a long long AND at least one of the
  209. * operands is cast to long long (usually just prior to the "*" so as
  210. * not to confuse it into thinking it really has a 64-bit operand,
  211. * which, buy the way, it can do, but it takes more code and at least 2
  212. * mpys).
  213. * We also need to be aware that one second in nanoseconds is only a
  214. * couple of bits away from overflowing a 32-bit word, so we MUST use
  215. * 64-bits to get the full range time in nanoseconds.
  216. */
  217. /*
  218. * Here are the scales we will use. One for seconds, nanoseconds and
  219. * microseconds.
  220. *
  221. * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and
  222. * check if the sign bit is set. If not, we bump the shift count by 1.
  223. * (Gets an extra bit of precision where we can use it.)
  224. * We know it is set for HZ = 1024 and HZ = 100 not for 1000.
  225. * Haven't tested others.
  226. * Limits of cpp (for #if expressions) only long (no long long), but
  227. * then we only need the most signicant bit.
  228. */
  229. #define SEC_JIFFIE_SC (31 - SHIFT_HZ)
  230. #if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000)
  231. #undef SEC_JIFFIE_SC
  232. #define SEC_JIFFIE_SC (32 - SHIFT_HZ)
  233. #endif
  234. #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29)
  235. #define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\
  236. TICK_NSEC -1) / (u64)TICK_NSEC))
  237. #define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\
  238. TICK_NSEC -1) / (u64)TICK_NSEC))
  239. /*
  240. * The maximum jiffie value is (MAX_INT >> 1). Here we translate that
  241. * into seconds. The 64-bit case will overflow if we are not careful,
  242. * so use the messy SH_DIV macro to do it. Still all constants.
  243. */
  244. #if BITS_PER_LONG < 64
  245. # define MAX_SEC_IN_JIFFIES \
  246. (long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC)
  247. #else /* take care of overflow on 64 bits machines */
  248. # define MAX_SEC_IN_JIFFIES \
  249. (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1)
  250. #endif
  251. /*
  252. * Convert various time units to each other:
  253. */
  254. extern unsigned int jiffies_to_msecs(const unsigned long j);
  255. extern unsigned int jiffies_to_usecs(const unsigned long j);
  256. static inline u64 jiffies_to_nsecs(const unsigned long j)
  257. {
  258. return (u64)jiffies_to_usecs(j) * NSEC_PER_USEC;
  259. }
  260. extern u64 jiffies64_to_nsecs(u64 j);
  261. extern u64 jiffies64_to_msecs(u64 j);
  262. extern unsigned long __msecs_to_jiffies(const unsigned int m);
  263. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  264. /*
  265. * HZ is equal to or smaller than 1000, and 1000 is a nice round
  266. * multiple of HZ, divide with the factor between them, but round
  267. * upwards:
  268. */
  269. static inline unsigned long _msecs_to_jiffies(const unsigned int m)
  270. {
  271. return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
  272. }
  273. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  274. /*
  275. * HZ is larger than 1000, and HZ is a nice round multiple of 1000 -
  276. * simply multiply with the factor between them.
  277. *
  278. * But first make sure the multiplication result cannot overflow:
  279. */
  280. static inline unsigned long _msecs_to_jiffies(const unsigned int m)
  281. {
  282. if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  283. return MAX_JIFFY_OFFSET;
  284. return m * (HZ / MSEC_PER_SEC);
  285. }
  286. #else
  287. /*
  288. * Generic case - multiply, round and divide. But first check that if
  289. * we are doing a net multiplication, that we wouldn't overflow:
  290. */
  291. static inline unsigned long _msecs_to_jiffies(const unsigned int m)
  292. {
  293. if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  294. return MAX_JIFFY_OFFSET;
  295. return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) >> MSEC_TO_HZ_SHR32;
  296. }
  297. #endif
  298. /**
  299. * msecs_to_jiffies: - convert milliseconds to jiffies
  300. * @m: time in milliseconds
  301. *
  302. * conversion is done as follows:
  303. *
  304. * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
  305. *
  306. * - 'too large' values [that would result in larger than
  307. * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
  308. *
  309. * - all other values are converted to jiffies by either multiplying
  310. * the input value by a factor or dividing it with a factor and
  311. * handling any 32-bit overflows.
  312. * for the details see __msecs_to_jiffies()
  313. *
  314. * msecs_to_jiffies() checks for the passed in value being a constant
  315. * via __builtin_constant_p() allowing gcc to eliminate most of the
  316. * code, __msecs_to_jiffies() is called if the value passed does not
  317. * allow constant folding and the actual conversion must be done at
  318. * runtime.
  319. * the HZ range specific helpers _msecs_to_jiffies() are called both
  320. * directly here and from __msecs_to_jiffies() in the case where
  321. * constant folding is not possible.
  322. */
  323. static __always_inline unsigned long msecs_to_jiffies(const unsigned int m)
  324. {
  325. if (__builtin_constant_p(m)) {
  326. if ((int)m < 0)
  327. return MAX_JIFFY_OFFSET;
  328. return _msecs_to_jiffies(m);
  329. } else {
  330. return __msecs_to_jiffies(m);
  331. }
  332. }
  333. extern unsigned long __usecs_to_jiffies(const unsigned int u);
  334. #if !(USEC_PER_SEC % HZ)
  335. static inline unsigned long _usecs_to_jiffies(const unsigned int u)
  336. {
  337. return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
  338. }
  339. #else
  340. static inline unsigned long _usecs_to_jiffies(const unsigned int u)
  341. {
  342. return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
  343. >> USEC_TO_HZ_SHR32;
  344. }
  345. #endif
  346. /**
  347. * usecs_to_jiffies: - convert microseconds to jiffies
  348. * @u: time in microseconds
  349. *
  350. * conversion is done as follows:
  351. *
  352. * - 'too large' values [that would result in larger than
  353. * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
  354. *
  355. * - all other values are converted to jiffies by either multiplying
  356. * the input value by a factor or dividing it with a factor and
  357. * handling any 32-bit overflows as for msecs_to_jiffies.
  358. *
  359. * usecs_to_jiffies() checks for the passed in value being a constant
  360. * via __builtin_constant_p() allowing gcc to eliminate most of the
  361. * code, __usecs_to_jiffies() is called if the value passed does not
  362. * allow constant folding and the actual conversion must be done at
  363. * runtime.
  364. * the HZ range specific helpers _usecs_to_jiffies() are called both
  365. * directly here and from __msecs_to_jiffies() in the case where
  366. * constant folding is not possible.
  367. */
  368. static __always_inline unsigned long usecs_to_jiffies(const unsigned int u)
  369. {
  370. if (__builtin_constant_p(u)) {
  371. if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
  372. return MAX_JIFFY_OFFSET;
  373. return _usecs_to_jiffies(u);
  374. } else {
  375. return __usecs_to_jiffies(u);
  376. }
  377. }
  378. extern unsigned long timespec64_to_jiffies(const struct timespec64 *value);
  379. extern void jiffies_to_timespec64(const unsigned long jiffies,
  380. struct timespec64 *value);
  381. extern clock_t jiffies_to_clock_t(unsigned long x);
  382. static inline clock_t jiffies_delta_to_clock_t(long delta)
  383. {
  384. return jiffies_to_clock_t(max(0L, delta));
  385. }
  386. static inline unsigned int jiffies_delta_to_msecs(long delta)
  387. {
  388. return jiffies_to_msecs(max(0L, delta));
  389. }
  390. extern unsigned long clock_t_to_jiffies(unsigned long x);
  391. extern u64 jiffies_64_to_clock_t(u64 x);
  392. extern u64 nsec_to_clock_t(u64 x);
  393. extern u64 nsecs_to_jiffies64(u64 n);
  394. extern unsigned long nsecs_to_jiffies(u64 n);
  395. #define TIMESTAMP_SIZE 30
  396. #endif