1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_JIFFIES_H 3 #define _LINUX_JIFFIES_H 4 5 #include <linux/cache.h> 6 #include <linux/limits.h> 7 #include <linux/math64.h> 8 #include <linux/minmax.h> 9 #include <linux/types.h> 10 #include <linux/time.h> 11 #include <linux/timex.h> 12 #include <vdso/jiffies.h> 13 #include <asm/param.h> /* for HZ */ 14 #include <generated/timeconst.h> 15 16 /* 17 * The following defines establish the engineering parameters of the PLL 18 * model. The HZ variable establishes the timer interrupt frequency, 100 Hz 19 * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the 20 * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the 21 * nearest power of two in order to avoid hardware multiply operations. 22 */ 23 #if HZ >= 12 && HZ < 24 24 # define SHIFT_HZ 4 25 #elif HZ >= 24 && HZ < 48 26 # define SHIFT_HZ 5 27 #elif HZ >= 48 && HZ < 96 28 # define SHIFT_HZ 6 29 #elif HZ >= 96 && HZ < 192 30 # define SHIFT_HZ 7 31 #elif HZ >= 192 && HZ < 384 32 # define SHIFT_HZ 8 33 #elif HZ >= 384 && HZ < 768 34 # define SHIFT_HZ 9 35 #elif HZ >= 768 && HZ < 1536 36 # define SHIFT_HZ 10 37 #elif HZ >= 1536 && HZ < 3072 38 # define SHIFT_HZ 11 39 #elif HZ >= 3072 && HZ < 6144 40 # define SHIFT_HZ 12 41 #elif HZ >= 6144 && HZ < 12288 42 # define SHIFT_HZ 13 43 #else 44 # error Invalid value of HZ. 45 #endif 46 47 /* Suppose we want to divide two numbers NOM and DEN: NOM/DEN, then we can 48 * improve accuracy by shifting LSH bits, hence calculating: 49 * (NOM << LSH) / DEN 50 * This however means trouble for large NOM, because (NOM << LSH) may no 51 * longer fit in 32 bits. The following way of calculating this gives us 52 * some slack, under the following conditions: 53 * - (NOM / DEN) fits in (32 - LSH) bits. 54 * - (NOM % DEN) fits in (32 - LSH) bits. 55 */ 56 #define SH_DIV(NOM,DEN,LSH) ( (((NOM) / (DEN)) << (LSH)) \ 57 + ((((NOM) % (DEN)) << (LSH)) + (DEN) / 2) / (DEN)) 58 59 /* LATCH is used in the interval timer and ftape setup. */ 60 #define LATCH ((CLOCK_TICK_RATE + HZ/2) / HZ) /* For divider */ 61 62 extern void register_refined_jiffies(long clock_tick_rate); 63 64 /* TICK_USEC is the time between ticks in usec */ 65 #define TICK_USEC ((USEC_PER_SEC + HZ/2) / HZ) 66 67 /* USER_TICK_USEC is the time between ticks in usec assuming fake USER_HZ */ 68 #define USER_TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ) 69 70 /* 71 * The 64-bit value is not atomic on 32-bit systems - you MUST NOT read it 72 * without sampling the sequence number in jiffies_lock. 73 * get_jiffies_64() will do this for you as appropriate. 74 * 75 * jiffies and jiffies_64 are at the same address for little-endian systems 76 * and for 64-bit big-endian systems. 77 * On 32-bit big-endian systems, jiffies is the lower 32 bits of jiffies_64 78 * (i.e., at address @jiffies_64 + 4). 79 * See arch/ARCH/kernel/vmlinux.lds.S 80 */ 81 extern u64 __cacheline_aligned_in_smp jiffies_64; 82 extern unsigned long volatile __cacheline_aligned_in_smp jiffies; 83 84 #if (BITS_PER_LONG < 64) 85 u64 get_jiffies_64(void); 86 #else 87 /** 88 * get_jiffies_64 - read the 64-bit non-atomic jiffies_64 value 89 * 90 * When BITS_PER_LONG < 64, this uses sequence number sampling using 91 * jiffies_lock to protect the 64-bit read. 92 * 93 * Return: current 64-bit jiffies value 94 */ 95 static inline u64 get_jiffies_64(void) 96 { 97 return (u64)jiffies; 98 } 99 #endif 100 101 /** 102 * DOC: General information about time_* inlines 103 * 104 * These inlines deal with timer wrapping correctly. You are strongly encouraged 105 * to use them: 106 * 107 * #. Because people otherwise forget 108 * #. Because if the timer wrap changes in future you won't have to alter your 109 * driver code. 110 */ 111 112 /** 113 * time_after - returns true if the time a is after time b. 114 * @a: first comparable as unsigned long 115 * @b: second comparable as unsigned long 116 * 117 * Do this with "<0" and ">=0" to only test the sign of the result. A 118 * good compiler would generate better code (and a really good compiler 119 * wouldn't care). Gcc is currently neither. 120 * 121 * Return: %true is time a is after time b, otherwise %false. 122 */ 123 #define time_after(a,b) \ 124 (typecheck(unsigned long, a) && \ 125 typecheck(unsigned long, b) && \ 126 ((long)((b) - (a)) < 0)) 127 /** 128 * time_before - returns true if the time a is before time b. 129 * @a: first comparable as unsigned long 130 * @b: second comparable as unsigned long 131 * 132 * Return: %true is time a is before time b, otherwise %false. 133 */ 134 #define time_before(a,b) time_after(b,a) 135 136 /** 137 * time_after_eq - returns true if the time a is after or the same as time b. 138 * @a: first comparable as unsigned long 139 * @b: second comparable as unsigned long 140 * 141 * Return: %true is time a is after or the same as time b, otherwise %false. 142 */ 143 #define time_after_eq(a,b) \ 144 (typecheck(unsigned long, a) && \ 145 typecheck(unsigned long, b) && \ 146 ((long)((a) - (b)) >= 0)) 147 /** 148 * time_before_eq - returns true if the time a is before or the same as time b. 149 * @a: first comparable as unsigned long 150 * @b: second comparable as unsigned long 151 * 152 * Return: %true is time a is before or the same as time b, otherwise %false. 153 */ 154 #define time_before_eq(a,b) time_after_eq(b,a) 155 156 /** 157 * time_in_range - Calculate whether a is in the range of [b, c]. 158 * @a: time to test 159 * @b: beginning of the range 160 * @c: end of the range 161 * 162 * Return: %true is time a is in the range [b, c], otherwise %false. 163 */ 164 #define time_in_range(a,b,c) \ 165 (time_after_eq(a,b) && \ 166 time_before_eq(a,c)) 167 168 /** 169 * time_in_range_open - Calculate whether a is in the range of [b, c). 170 * @a: time to test 171 * @b: beginning of the range 172 * @c: end of the range 173 * 174 * Return: %true is time a is in the range [b, c), otherwise %false. 175 */ 176 #define time_in_range_open(a,b,c) \ 177 (time_after_eq(a,b) && \ 178 time_before(a,c)) 179 180 /* Same as above, but does so with platform independent 64bit types. 181 * These must be used when utilizing jiffies_64 (i.e. return value of 182 * get_jiffies_64()). */ 183 184 /** 185 * time_after64 - returns true if the time a is after time b. 186 * @a: first comparable as __u64 187 * @b: second comparable as __u64 188 * 189 * This must be used when utilizing jiffies_64 (i.e. return value of 190 * get_jiffies_64()). 191 * 192 * Return: %true is time a is after time b, otherwise %false. 193 */ 194 #define time_after64(a,b) \ 195 (typecheck(__u64, a) && \ 196 typecheck(__u64, b) && \ 197 ((__s64)((b) - (a)) < 0)) 198 /** 199 * time_before64 - returns true if the time a is before time b. 200 * @a: first comparable as __u64 201 * @b: second comparable as __u64 202 * 203 * This must be used when utilizing jiffies_64 (i.e. return value of 204 * get_jiffies_64()). 205 * 206 * Return: %true is time a is before time b, otherwise %false. 207 */ 208 #define time_before64(a,b) time_after64(b,a) 209 210 /** 211 * time_after_eq64 - returns true if the time a is after or the same as time b. 212 * @a: first comparable as __u64 213 * @b: second comparable as __u64 214 * 215 * This must be used when utilizing jiffies_64 (i.e. return value of 216 * get_jiffies_64()). 217 * 218 * Return: %true is time a is after or the same as time b, otherwise %false. 219 */ 220 #define time_after_eq64(a,b) \ 221 (typecheck(__u64, a) && \ 222 typecheck(__u64, b) && \ 223 ((__s64)((a) - (b)) >= 0)) 224 /** 225 * time_before_eq64 - returns true if the time a is before or the same as time b. 226 * @a: first comparable as __u64 227 * @b: second comparable as __u64 228 * 229 * This must be used when utilizing jiffies_64 (i.e. return value of 230 * get_jiffies_64()). 231 * 232 * Return: %true is time a is before or the same as time b, otherwise %false. 233 */ 234 #define time_before_eq64(a,b) time_after_eq64(b,a) 235 236 /** 237 * time_in_range64 - Calculate whether a is in the range of [b, c]. 238 * @a: time to test 239 * @b: beginning of the range 240 * @c: end of the range 241 * 242 * Return: %true is time a is in the range [b, c], otherwise %false. 243 */ 244 #define time_in_range64(a, b, c) \ 245 (time_after_eq64(a, b) && \ 246 time_before_eq64(a, c)) 247 248 /* 249 * These eight macros compare jiffies[_64] and 'a' for convenience. 250 */ 251 252 /** 253 * time_is_before_jiffies - return true if a is before jiffies 254 * @a: time (unsigned long) to compare to jiffies 255 * 256 * Return: %true is time a is before jiffies, otherwise %false. 257 */ 258 #define time_is_before_jiffies(a) time_after(jiffies, a) 259 /** 260 * time_is_before_jiffies64 - return true if a is before jiffies_64 261 * @a: time (__u64) to compare to jiffies_64 262 * 263 * Return: %true is time a is before jiffies_64, otherwise %false. 264 */ 265 #define time_is_before_jiffies64(a) time_after64(get_jiffies_64(), a) 266 267 /** 268 * time_is_after_jiffies - return true if a is after jiffies 269 * @a: time (unsigned long) to compare to jiffies 270 * 271 * Return: %true is time a is after jiffies, otherwise %false. 272 */ 273 #define time_is_after_jiffies(a) time_before(jiffies, a) 274 /** 275 * time_is_after_jiffies64 - return true if a is after jiffies_64 276 * @a: time (__u64) to compare to jiffies_64 277 * 278 * Return: %true is time a is after jiffies_64, otherwise %false. 279 */ 280 #define time_is_after_jiffies64(a) time_before64(get_jiffies_64(), a) 281 282 /** 283 * time_is_before_eq_jiffies - return true if a is before or equal to jiffies 284 * @a: time (unsigned long) to compare to jiffies 285 * 286 * Return: %true is time a is before or the same as jiffies, otherwise %false. 287 */ 288 #define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a) 289 /** 290 * time_is_before_eq_jiffies64 - return true if a is before or equal to jiffies_64 291 * @a: time (__u64) to compare to jiffies_64 292 * 293 * Return: %true is time a is before or the same jiffies_64, otherwise %false. 294 */ 295 #define time_is_before_eq_jiffies64(a) time_after_eq64(get_jiffies_64(), a) 296 297 /** 298 * time_is_after_eq_jiffies - return true if a is after or equal to jiffies 299 * @a: time (unsigned long) to compare to jiffies 300 * 301 * Return: %true is time a is after or the same as jiffies, otherwise %false. 302 */ 303 #define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a) 304 /** 305 * time_is_after_eq_jiffies64 - return true if a is after or equal to jiffies_64 306 * @a: time (__u64) to compare to jiffies_64 307 * 308 * Return: %true is time a is after or the same as jiffies_64, otherwise %false. 309 */ 310 #define time_is_after_eq_jiffies64(a) time_before_eq64(get_jiffies_64(), a) 311 312 /* 313 * Have the 32-bit jiffies value wrap 5 minutes after boot 314 * so jiffies wrap bugs show up earlier. 315 */ 316 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ)) 317 318 /* 319 * Change timeval to jiffies, trying to avoid the 320 * most obvious overflows.. 321 * 322 * And some not so obvious. 323 * 324 * Note that we don't want to return LONG_MAX, because 325 * for various timeout reasons we often end up having 326 * to wait "jiffies+1" in order to guarantee that we wait 327 * at _least_ "jiffies" - so "jiffies+1" had better still 328 * be positive. 329 */ 330 #define MAX_JIFFY_OFFSET ((LONG_MAX >> 1)-1) 331 332 extern unsigned long preset_lpj; 333 334 /* 335 * We want to do realistic conversions of time so we need to use the same 336 * values the update wall clock code uses as the jiffies size. This value 337 * is: TICK_NSEC (which is defined in timex.h). This 338 * is a constant and is in nanoseconds. We will use scaled math 339 * with a set of scales defined here as SEC_JIFFIE_SC, USEC_JIFFIE_SC and 340 * NSEC_JIFFIE_SC. Note that these defines contain nothing but 341 * constants and so are computed at compile time. SHIFT_HZ (computed in 342 * timex.h) adjusts the scaling for different HZ values. 343 344 * Scaled math??? What is that? 345 * 346 * Scaled math is a way to do integer math on values that would, 347 * otherwise, either overflow, underflow, or cause undesired div 348 * instructions to appear in the execution path. In short, we "scale" 349 * up the operands so they take more bits (more precision, less 350 * underflow), do the desired operation and then "scale" the result back 351 * by the same amount. If we do the scaling by shifting we avoid the 352 * costly mpy and the dastardly div instructions. 353 354 * Suppose, for example, we want to convert from seconds to jiffies 355 * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE. The 356 * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We 357 * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we 358 * might calculate at compile time, however, the result will only have 359 * about 3-4 bits of precision (less for smaller values of HZ). 360 * 361 * So, we scale as follows: 362 * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE); 363 * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE; 364 * Then we make SCALE a power of two so: 365 * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE; 366 * Now we define: 367 * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) 368 * jiff = (sec * SEC_CONV) >> SCALE; 369 * 370 * Often the math we use will expand beyond 32-bits so we tell C how to 371 * do this and pass the 64-bit result of the mpy through the ">> SCALE" 372 * which should take the result back to 32-bits. We want this expansion 373 * to capture as much precision as possible. At the same time we don't 374 * want to overflow so we pick the SCALE to avoid this. In this file, 375 * that means using a different scale for each range of HZ values (as 376 * defined in timex.h). 377 * 378 * For those who want to know, gcc will give a 64-bit result from a "*" 379 * operator if the result is a long long AND at least one of the 380 * operands is cast to long long (usually just prior to the "*" so as 381 * not to confuse it into thinking it really has a 64-bit operand, 382 * which, buy the way, it can do, but it takes more code and at least 2 383 * mpys). 384 385 * We also need to be aware that one second in nanoseconds is only a 386 * couple of bits away from overflowing a 32-bit word, so we MUST use 387 * 64-bits to get the full range time in nanoseconds. 388 389 */ 390 391 /* 392 * Here are the scales we will use. One for seconds, nanoseconds and 393 * microseconds. 394 * 395 * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and 396 * check if the sign bit is set. If not, we bump the shift count by 1. 397 * (Gets an extra bit of precision where we can use it.) 398 * We know it is set for HZ = 1024 and HZ = 100 not for 1000. 399 * Haven't tested others. 400 401 * Limits of cpp (for #if expressions) only long (no long long), but 402 * then we only need the most signicant bit. 403 */ 404 405 #define SEC_JIFFIE_SC (31 - SHIFT_HZ) 406 #if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000) 407 #undef SEC_JIFFIE_SC 408 #define SEC_JIFFIE_SC (32 - SHIFT_HZ) 409 #endif 410 #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29) 411 #define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\ 412 TICK_NSEC -1) / (u64)TICK_NSEC)) 413 414 #define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\ 415 TICK_NSEC -1) / (u64)TICK_NSEC)) 416 /* 417 * The maximum jiffy value is (MAX_INT >> 1). Here we translate that 418 * into seconds. The 64-bit case will overflow if we are not careful, 419 * so use the messy SH_DIV macro to do it. Still all constants. 420 */ 421 #if BITS_PER_LONG < 64 422 # define MAX_SEC_IN_JIFFIES \ 423 (long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC) 424 #else /* take care of overflow on 64-bit machines */ 425 # define MAX_SEC_IN_JIFFIES \ 426 (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1) 427 428 #endif 429 430 /* 431 * Convert various time units to each other: 432 */ 433 434 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 435 /** 436 * jiffies_to_msecs - Convert jiffies to milliseconds 437 * @j: jiffies value 438 * 439 * This inline version takes care of HZ in {100,250,1000}. 440 * 441 * Return: milliseconds value 442 */ 443 static inline unsigned int jiffies_to_msecs(const unsigned long j) 444 { 445 return (MSEC_PER_SEC / HZ) * j; 446 } 447 #else 448 unsigned int jiffies_to_msecs(const unsigned long j); 449 #endif 450 451 #if !(USEC_PER_SEC % HZ) 452 /** 453 * jiffies_to_usecs - Convert jiffies to microseconds 454 * @j: jiffies value 455 * 456 * Return: microseconds value 457 */ 458 static inline unsigned int jiffies_to_usecs(const unsigned long j) 459 { 460 /* 461 * Hz usually doesn't go much further MSEC_PER_SEC. 462 * jiffies_to_usecs() and usecs_to_jiffies() depend on that. 463 */ 464 BUILD_BUG_ON(HZ > USEC_PER_SEC); 465 466 return (USEC_PER_SEC / HZ) * j; 467 } 468 #else 469 unsigned int jiffies_to_usecs(const unsigned long j); 470 #endif 471 472 /** 473 * jiffies_to_nsecs - Convert jiffies to nanoseconds 474 * @j: jiffies value 475 * 476 * Return: nanoseconds value 477 */ 478 static inline u64 jiffies_to_nsecs(const unsigned long j) 479 { 480 return (u64)jiffies_to_usecs(j) * NSEC_PER_USEC; 481 } 482 483 extern u64 jiffies64_to_nsecs(u64 j); 484 extern u64 jiffies64_to_msecs(u64 j); 485 486 extern unsigned long __msecs_to_jiffies(const unsigned int m); 487 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 488 /* 489 * HZ is equal to or smaller than 1000, and 1000 is a nice round 490 * multiple of HZ, divide with the factor between them, but round 491 * upwards: 492 */ 493 static inline unsigned long _msecs_to_jiffies(const unsigned int m) 494 { 495 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ); 496 } 497 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) 498 /* 499 * HZ is larger than 1000, and HZ is a nice round multiple of 1000 - 500 * simply multiply with the factor between them. 501 * 502 * But first make sure the multiplication result cannot overflow: 503 */ 504 static inline unsigned long _msecs_to_jiffies(const unsigned int m) 505 { 506 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) 507 return MAX_JIFFY_OFFSET; 508 return m * (HZ / MSEC_PER_SEC); 509 } 510 #else 511 /* 512 * Generic case - multiply, round and divide. But first check that if 513 * we are doing a net multiplication, that we wouldn't overflow: 514 */ 515 static inline unsigned long _msecs_to_jiffies(const unsigned int m) 516 { 517 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) 518 return MAX_JIFFY_OFFSET; 519 520 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) >> MSEC_TO_HZ_SHR32; 521 } 522 #endif 523 /** 524 * msecs_to_jiffies: - convert milliseconds to jiffies 525 * @m: time in milliseconds 526 * 527 * conversion is done as follows: 528 * 529 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET) 530 * 531 * - 'too large' values [that would result in larger than 532 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. 533 * 534 * - all other values are converted to jiffies by either multiplying 535 * the input value by a factor or dividing it with a factor and 536 * handling any 32-bit overflows. 537 * for the details see _msecs_to_jiffies() 538 * 539 * msecs_to_jiffies() checks for the passed in value being a constant 540 * via __builtin_constant_p() allowing gcc to eliminate most of the 541 * code. __msecs_to_jiffies() is called if the value passed does not 542 * allow constant folding and the actual conversion must be done at 543 * runtime. 544 * The HZ range specific helpers _msecs_to_jiffies() are called both 545 * directly here and from __msecs_to_jiffies() in the case where 546 * constant folding is not possible. 547 * 548 * Return: jiffies value 549 */ 550 static __always_inline unsigned long msecs_to_jiffies(const unsigned int m) 551 { 552 if (__builtin_constant_p(m)) { 553 if ((int)m < 0) 554 return MAX_JIFFY_OFFSET; 555 return _msecs_to_jiffies(m); 556 } else { 557 return __msecs_to_jiffies(m); 558 } 559 } 560 561 /** 562 * secs_to_jiffies: - convert seconds to jiffies 563 * @_secs: time in seconds 564 * 565 * Conversion is done by simple multiplication with HZ 566 * 567 * secs_to_jiffies() is defined as a macro rather than a static inline 568 * function so it can be used in static initializers. 569 * 570 * Return: jiffies value 571 */ 572 #define secs_to_jiffies(_secs) (unsigned long)((_secs) * HZ) 573 574 extern unsigned long __usecs_to_jiffies(const unsigned int u); 575 #if !(USEC_PER_SEC % HZ) 576 static inline unsigned long _usecs_to_jiffies(const unsigned int u) 577 { 578 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ); 579 } 580 #else 581 static inline unsigned long _usecs_to_jiffies(const unsigned int u) 582 { 583 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32) 584 >> USEC_TO_HZ_SHR32; 585 } 586 #endif 587 588 /** 589 * usecs_to_jiffies: - convert microseconds to jiffies 590 * @u: time in microseconds 591 * 592 * conversion is done as follows: 593 * 594 * - 'too large' values [that would result in larger than 595 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. 596 * 597 * - all other values are converted to jiffies by either multiplying 598 * the input value by a factor or dividing it with a factor and 599 * handling any 32-bit overflows as for msecs_to_jiffies. 600 * 601 * usecs_to_jiffies() checks for the passed in value being a constant 602 * via __builtin_constant_p() allowing gcc to eliminate most of the 603 * code. __usecs_to_jiffies() is called if the value passed does not 604 * allow constant folding and the actual conversion must be done at 605 * runtime. 606 * The HZ range specific helpers _usecs_to_jiffies() are called both 607 * directly here and from __msecs_to_jiffies() in the case where 608 * constant folding is not possible. 609 * 610 * Return: jiffies value 611 */ 612 static __always_inline unsigned long usecs_to_jiffies(const unsigned int u) 613 { 614 if (__builtin_constant_p(u)) { 615 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET)) 616 return MAX_JIFFY_OFFSET; 617 return _usecs_to_jiffies(u); 618 } else { 619 return __usecs_to_jiffies(u); 620 } 621 } 622 623 extern unsigned long timespec64_to_jiffies(const struct timespec64 *value); 624 extern void jiffies_to_timespec64(const unsigned long jiffies, 625 struct timespec64 *value); 626 extern clock_t jiffies_to_clock_t(unsigned long x); 627 628 static inline clock_t jiffies_delta_to_clock_t(long delta) 629 { 630 return jiffies_to_clock_t(max(0L, delta)); 631 } 632 633 static inline unsigned int jiffies_delta_to_msecs(long delta) 634 { 635 return jiffies_to_msecs(max(0L, delta)); 636 } 637 638 extern unsigned long clock_t_to_jiffies(unsigned long x); 639 extern u64 jiffies_64_to_clock_t(u64 x); 640 extern u64 nsec_to_clock_t(u64 x); 641 extern u64 nsecs_to_jiffies64(u64 n); 642 extern unsigned long nsecs_to_jiffies(u64 n); 643 644 #define TIMESTAMP_SIZE 30 645 646 struct ctl_table; 647 int proc_dointvec_jiffies(const struct ctl_table *table, int dir, void *buffer, 648 size_t *lenp, loff_t *ppos); 649 int proc_dointvec_ms_jiffies_minmax(const struct ctl_table *table, int dir, 650 void *buffer, size_t *lenp, loff_t *ppos); 651 int proc_dointvec_userhz_jiffies(const struct ctl_table *table, int dir, 652 void *buffer, size_t *lenp, loff_t *ppos); 653 int proc_dointvec_ms_jiffies(const struct ctl_table *table, int dir, void *buffer, 654 size_t *lenp, loff_t *ppos); 655 int proc_doulongvec_ms_jiffies_minmax(const struct ctl_table *table, int dir, 656 void *buffer, size_t *lenp, loff_t *ppos); 657 658 #endif 659