jiffies.h 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444
  1. #ifndef _LINUX_JIFFIES_H
  2. #define _LINUX_JIFFIES_H
  3. #include <linux/calc64.h>
  4. #include <linux/kernel.h>
  5. #include <linux/types.h>
  6. #include <linux/time.h>
  7. #include <linux/timex.h>
  8. #include <asm/param.h> /* for HZ */
  9. /*
  10. * The following defines establish the engineering parameters of the PLL
  11. * model. The HZ variable establishes the timer interrupt frequency, 100 Hz
  12. * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the
  13. * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the
  14. * nearest power of two in order to avoid hardware multiply operations.
  15. */
  16. #if HZ >= 12 && HZ < 24
  17. # define SHIFT_HZ 4
  18. #elif HZ >= 24 && HZ < 48
  19. # define SHIFT_HZ 5
  20. #elif HZ >= 48 && HZ < 96
  21. # define SHIFT_HZ 6
  22. #elif HZ >= 96 && HZ < 192
  23. # define SHIFT_HZ 7
  24. #elif HZ >= 192 && HZ < 384
  25. # define SHIFT_HZ 8
  26. #elif HZ >= 384 && HZ < 768
  27. # define SHIFT_HZ 9
  28. #elif HZ >= 768 && HZ < 1536
  29. # define SHIFT_HZ 10
  30. #else
  31. # error You lose.
  32. #endif
  33. /* LATCH is used in the interval timer and ftape setup. */
  34. #define LATCH ((CLOCK_TICK_RATE + HZ/2) / HZ) /* For divider */
  35. /* Suppose we want to devide two numbers NOM and DEN: NOM/DEN, the we can
  36. * improve accuracy by shifting LSH bits, hence calculating:
  37. * (NOM << LSH) / DEN
  38. * This however means trouble for large NOM, because (NOM << LSH) may no
  39. * longer fit in 32 bits. The following way of calculating this gives us
  40. * some slack, under the following conditions:
  41. * - (NOM / DEN) fits in (32 - LSH) bits.
  42. * - (NOM % DEN) fits in (32 - LSH) bits.
  43. */
  44. #define SH_DIV(NOM,DEN,LSH) ( ((NOM / DEN) << LSH) \
  45. + (((NOM % DEN) << LSH) + DEN / 2) / DEN)
  46. /* HZ is the requested value. ACTHZ is actual HZ ("<< 8" is for accuracy) */
  47. #define ACTHZ (SH_DIV (CLOCK_TICK_RATE, LATCH, 8))
  48. /* TICK_NSEC is the time between ticks in nsec assuming real ACTHZ */
  49. #define TICK_NSEC (SH_DIV (1000000UL * 1000, ACTHZ, 8))
  50. /* TICK_USEC is the time between ticks in usec assuming fake USER_HZ */
  51. #define TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ)
  52. /* TICK_USEC_TO_NSEC is the time between ticks in nsec assuming real ACTHZ and */
  53. /* a value TUSEC for TICK_USEC (can be set bij adjtimex) */
  54. #define TICK_USEC_TO_NSEC(TUSEC) (SH_DIV (TUSEC * USER_HZ * 1000, ACTHZ, 8))
  55. /* some arch's have a small-data section that can be accessed register-relative
  56. * but that can only take up to, say, 4-byte variables. jiffies being part of
  57. * an 8-byte variable may not be correctly accessed unless we force the issue
  58. */
  59. #define __jiffy_data __attribute__((section(".data")))
  60. /*
  61. * The 64-bit value is not volatile - you MUST NOT read it
  62. * without sampling the sequence number in xtime_lock.
  63. * get_jiffies_64() will do this for you as appropriate.
  64. */
  65. extern u64 __jiffy_data jiffies_64;
  66. extern unsigned long volatile __jiffy_data jiffies;
  67. #if (BITS_PER_LONG < 64)
  68. u64 get_jiffies_64(void);
  69. #else
  70. static inline u64 get_jiffies_64(void)
  71. {
  72. return (u64)jiffies;
  73. }
  74. #endif
  75. /*
  76. * These inlines deal with timer wrapping correctly. You are
  77. * strongly encouraged to use them
  78. * 1. Because people otherwise forget
  79. * 2. Because if the timer wrap changes in future you won't have to
  80. * alter your driver code.
  81. *
  82. * time_after(a,b) returns true if the time a is after time b.
  83. *
  84. * Do this with "<0" and ">=0" to only test the sign of the result. A
  85. * good compiler would generate better code (and a really good compiler
  86. * wouldn't care). Gcc is currently neither.
  87. */
  88. #define time_after(a,b) \
  89. (typecheck(unsigned long, a) && \
  90. typecheck(unsigned long, b) && \
  91. ((long)(b) - (long)(a) < 0))
  92. #define time_before(a,b) time_after(b,a)
  93. #define time_after_eq(a,b) \
  94. (typecheck(unsigned long, a) && \
  95. typecheck(unsigned long, b) && \
  96. ((long)(a) - (long)(b) >= 0))
  97. #define time_before_eq(a,b) time_after_eq(b,a)
  98. /*
  99. * Have the 32 bit jiffies value wrap 5 minutes after boot
  100. * so jiffies wrap bugs show up earlier.
  101. */
  102. #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  103. /*
  104. * Change timeval to jiffies, trying to avoid the
  105. * most obvious overflows..
  106. *
  107. * And some not so obvious.
  108. *
  109. * Note that we don't want to return MAX_LONG, because
  110. * for various timeout reasons we often end up having
  111. * to wait "jiffies+1" in order to guarantee that we wait
  112. * at _least_ "jiffies" - so "jiffies+1" had better still
  113. * be positive.
  114. */
  115. #define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)
  116. /*
  117. * We want to do realistic conversions of time so we need to use the same
  118. * values the update wall clock code uses as the jiffies size. This value
  119. * is: TICK_NSEC (which is defined in timex.h). This
  120. * is a constant and is in nanoseconds. We will used scaled math
  121. * with a set of scales defined here as SEC_JIFFIE_SC, USEC_JIFFIE_SC and
  122. * NSEC_JIFFIE_SC. Note that these defines contain nothing but
  123. * constants and so are computed at compile time. SHIFT_HZ (computed in
  124. * timex.h) adjusts the scaling for different HZ values.
  125. * Scaled math??? What is that?
  126. *
  127. * Scaled math is a way to do integer math on values that would,
  128. * otherwise, either overflow, underflow, or cause undesired div
  129. * instructions to appear in the execution path. In short, we "scale"
  130. * up the operands so they take more bits (more precision, less
  131. * underflow), do the desired operation and then "scale" the result back
  132. * by the same amount. If we do the scaling by shifting we avoid the
  133. * costly mpy and the dastardly div instructions.
  134. * Suppose, for example, we want to convert from seconds to jiffies
  135. * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE. The
  136. * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We
  137. * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we
  138. * might calculate at compile time, however, the result will only have
  139. * about 3-4 bits of precision (less for smaller values of HZ).
  140. *
  141. * So, we scale as follows:
  142. * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE);
  143. * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE;
  144. * Then we make SCALE a power of two so:
  145. * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE;
  146. * Now we define:
  147. * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE))
  148. * jiff = (sec * SEC_CONV) >> SCALE;
  149. *
  150. * Often the math we use will expand beyond 32-bits so we tell C how to
  151. * do this and pass the 64-bit result of the mpy through the ">> SCALE"
  152. * which should take the result back to 32-bits. We want this expansion
  153. * to capture as much precision as possible. At the same time we don't
  154. * want to overflow so we pick the SCALE to avoid this. In this file,
  155. * that means using a different scale for each range of HZ values (as
  156. * defined in timex.h).
  157. *
  158. * For those who want to know, gcc will give a 64-bit result from a "*"
  159. * operator if the result is a long long AND at least one of the
  160. * operands is cast to long long (usually just prior to the "*" so as
  161. * not to confuse it into thinking it really has a 64-bit operand,
  162. * which, buy the way, it can do, but it take more code and at least 2
  163. * mpys).
  164. * We also need to be aware that one second in nanoseconds is only a
  165. * couple of bits away from overflowing a 32-bit word, so we MUST use
  166. * 64-bits to get the full range time in nanoseconds.
  167. */
  168. /*
  169. * Here are the scales we will use. One for seconds, nanoseconds and
  170. * microseconds.
  171. *
  172. * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and
  173. * check if the sign bit is set. If not, we bump the shift count by 1.
  174. * (Gets an extra bit of precision where we can use it.)
  175. * We know it is set for HZ = 1024 and HZ = 100 not for 1000.
  176. * Haven't tested others.
  177. * Limits of cpp (for #if expressions) only long (no long long), but
  178. * then we only need the most signicant bit.
  179. */
  180. #define SEC_JIFFIE_SC (31 - SHIFT_HZ)
  181. #if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000)
  182. #undef SEC_JIFFIE_SC
  183. #define SEC_JIFFIE_SC (32 - SHIFT_HZ)
  184. #endif
  185. #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29)
  186. #define USEC_JIFFIE_SC (SEC_JIFFIE_SC + 19)
  187. #define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\
  188. TICK_NSEC -1) / (u64)TICK_NSEC))
  189. #define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\
  190. TICK_NSEC -1) / (u64)TICK_NSEC))
  191. #define USEC_CONVERSION \
  192. ((unsigned long)((((u64)NSEC_PER_USEC << USEC_JIFFIE_SC) +\
  193. TICK_NSEC -1) / (u64)TICK_NSEC))
  194. /*
  195. * USEC_ROUND is used in the timeval to jiffie conversion. See there
  196. * for more details. It is the scaled resolution rounding value. Note
  197. * that it is a 64-bit value. Since, when it is applied, we are already
  198. * in jiffies (albit scaled), it is nothing but the bits we will shift
  199. * off.
  200. */
  201. #define USEC_ROUND (u64)(((u64)1 << USEC_JIFFIE_SC) - 1)
  202. /*
  203. * The maximum jiffie value is (MAX_INT >> 1). Here we translate that
  204. * into seconds. The 64-bit case will overflow if we are not careful,
  205. * so use the messy SH_DIV macro to do it. Still all constants.
  206. */
  207. #if BITS_PER_LONG < 64
  208. # define MAX_SEC_IN_JIFFIES \
  209. (long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC)
  210. #else /* take care of overflow on 64 bits machines */
  211. # define MAX_SEC_IN_JIFFIES \
  212. (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1)
  213. #endif
  214. /*
  215. * Convert jiffies to milliseconds and back.
  216. *
  217. * Avoid unnecessary multiplications/divisions in the
  218. * two most common HZ cases:
  219. */
  220. static inline unsigned int jiffies_to_msecs(const unsigned long j)
  221. {
  222. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  223. return (MSEC_PER_SEC / HZ) * j;
  224. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  225. return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
  226. #else
  227. return (j * MSEC_PER_SEC) / HZ;
  228. #endif
  229. }
  230. static inline unsigned int jiffies_to_usecs(const unsigned long j)
  231. {
  232. #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
  233. return (USEC_PER_SEC / HZ) * j;
  234. #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
  235. return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
  236. #else
  237. return (j * USEC_PER_SEC) / HZ;
  238. #endif
  239. }
  240. static inline unsigned long msecs_to_jiffies(const unsigned int m)
  241. {
  242. if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  243. return MAX_JIFFY_OFFSET;
  244. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  245. return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
  246. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  247. return m * (HZ / MSEC_PER_SEC);
  248. #else
  249. return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
  250. #endif
  251. }
  252. static inline unsigned long usecs_to_jiffies(const unsigned int u)
  253. {
  254. if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
  255. return MAX_JIFFY_OFFSET;
  256. #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
  257. return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
  258. #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
  259. return u * (HZ / USEC_PER_SEC);
  260. #else
  261. return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
  262. #endif
  263. }
  264. /*
  265. * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
  266. * that a remainder subtract here would not do the right thing as the
  267. * resolution values don't fall on second boundries. I.e. the line:
  268. * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
  269. *
  270. * Rather, we just shift the bits off the right.
  271. *
  272. * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
  273. * value to a scaled second value.
  274. */
  275. static __inline__ unsigned long
  276. timespec_to_jiffies(const struct timespec *value)
  277. {
  278. unsigned long sec = value->tv_sec;
  279. long nsec = value->tv_nsec + TICK_NSEC - 1;
  280. if (sec >= MAX_SEC_IN_JIFFIES){
  281. sec = MAX_SEC_IN_JIFFIES;
  282. nsec = 0;
  283. }
  284. return (((u64)sec * SEC_CONVERSION) +
  285. (((u64)nsec * NSEC_CONVERSION) >>
  286. (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
  287. }
  288. static __inline__ void
  289. jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
  290. {
  291. /*
  292. * Convert jiffies to nanoseconds and separate with
  293. * one divide.
  294. */
  295. u64 nsec = (u64)jiffies * TICK_NSEC;
  296. value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
  297. }
  298. /* Same for "timeval"
  299. *
  300. * Well, almost. The problem here is that the real system resolution is
  301. * in nanoseconds and the value being converted is in micro seconds.
  302. * Also for some machines (those that use HZ = 1024, in-particular),
  303. * there is a LARGE error in the tick size in microseconds.
  304. * The solution we use is to do the rounding AFTER we convert the
  305. * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
  306. * Instruction wise, this should cost only an additional add with carry
  307. * instruction above the way it was done above.
  308. */
  309. static __inline__ unsigned long
  310. timeval_to_jiffies(const struct timeval *value)
  311. {
  312. unsigned long sec = value->tv_sec;
  313. long usec = value->tv_usec;
  314. if (sec >= MAX_SEC_IN_JIFFIES){
  315. sec = MAX_SEC_IN_JIFFIES;
  316. usec = 0;
  317. }
  318. return (((u64)sec * SEC_CONVERSION) +
  319. (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
  320. (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
  321. }
  322. static __inline__ void
  323. jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
  324. {
  325. /*
  326. * Convert jiffies to nanoseconds and separate with
  327. * one divide.
  328. */
  329. u64 nsec = (u64)jiffies * TICK_NSEC;
  330. long tv_usec;
  331. value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
  332. tv_usec /= NSEC_PER_USEC;
  333. value->tv_usec = tv_usec;
  334. }
  335. /*
  336. * Convert jiffies/jiffies_64 to clock_t and back.
  337. */
  338. static inline clock_t jiffies_to_clock_t(long x)
  339. {
  340. #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
  341. return x / (HZ / USER_HZ);
  342. #else
  343. u64 tmp = (u64)x * TICK_NSEC;
  344. do_div(tmp, (NSEC_PER_SEC / USER_HZ));
  345. return (long)tmp;
  346. #endif
  347. }
  348. static inline unsigned long clock_t_to_jiffies(unsigned long x)
  349. {
  350. #if (HZ % USER_HZ)==0
  351. if (x >= ~0UL / (HZ / USER_HZ))
  352. return ~0UL;
  353. return x * (HZ / USER_HZ);
  354. #else
  355. u64 jif;
  356. /* Don't worry about loss of precision here .. */
  357. if (x >= ~0UL / HZ * USER_HZ)
  358. return ~0UL;
  359. /* .. but do try to contain it here */
  360. jif = x * (u64) HZ;
  361. do_div(jif, USER_HZ);
  362. return jif;
  363. #endif
  364. }
  365. static inline u64 jiffies_64_to_clock_t(u64 x)
  366. {
  367. #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
  368. do_div(x, HZ / USER_HZ);
  369. #else
  370. /*
  371. * There are better ways that don't overflow early,
  372. * but even this doesn't overflow in hundreds of years
  373. * in 64 bits, so..
  374. */
  375. x *= TICK_NSEC;
  376. do_div(x, (NSEC_PER_SEC / USER_HZ));
  377. #endif
  378. return x;
  379. }
  380. static inline u64 nsec_to_clock_t(u64 x)
  381. {
  382. #if (NSEC_PER_SEC % USER_HZ) == 0
  383. do_div(x, (NSEC_PER_SEC / USER_HZ));
  384. #elif (USER_HZ % 512) == 0
  385. x *= USER_HZ/512;
  386. do_div(x, (NSEC_PER_SEC / 512));
  387. #else
  388. /*
  389. * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
  390. * overflow after 64.99 years.
  391. * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
  392. */
  393. x *= 9;
  394. do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2))
  395. / USER_HZ));
  396. #endif
  397. return x;
  398. }
  399. #endif