| 292,11 → 292,145 |
|---|
| return (u64)jiffies_to_usecs(j) * NSEC_PER_USEC; |
| } |
| |
| extern unsigned long msecs_to_jiffies(const unsigned int m); |
| extern unsigned long usecs_to_jiffies(const unsigned int u); |
| extern unsigned long timespec_to_jiffies(const struct timespec *value); |
| extern void jiffies_to_timespec(const unsigned long jiffies, |
| struct timespec *value); |
| extern unsigned long __msecs_to_jiffies(const unsigned int m); |
| #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) |
| /* |
| * HZ is equal to or smaller than 1000, and 1000 is a nice round |
| * multiple of HZ, divide with the factor between them, but round |
| * upwards: |
| */ |
| static inline unsigned long _msecs_to_jiffies(const unsigned int m) |
| { |
| return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ); |
| } |
| #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) |
| /* |
| * HZ is larger than 1000, and HZ is a nice round multiple of 1000 - |
| * simply multiply with the factor between them. |
| * |
| * But first make sure the multiplication result cannot overflow: |
| */ |
| static inline unsigned long _msecs_to_jiffies(const unsigned int m) |
| { |
| if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) |
| return MAX_JIFFY_OFFSET; |
| return m * (HZ / MSEC_PER_SEC); |
| } |
| #else |
| /* |
| * Generic case - multiply, round and divide. But first check that if |
| * we are doing a net multiplication, that we wouldn't overflow: |
| */ |
| static inline unsigned long _msecs_to_jiffies(const unsigned int m) |
| { |
| if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) |
| return MAX_JIFFY_OFFSET; |
| |
| return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) >> MSEC_TO_HZ_SHR32; |
| } |
| #endif |
| /** |
| * msecs_to_jiffies: - convert milliseconds to jiffies |
| * @m: time in milliseconds |
| * |
| * conversion is done as follows: |
| * |
| * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET) |
| * |
| * - 'too large' values [that would result in larger than |
| * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. |
| * |
| * - all other values are converted to jiffies by either multiplying |
| * the input value by a factor or dividing it with a factor and |
| * handling any 32-bit overflows. |
| * for the details see __msecs_to_jiffies() |
| * |
| * msecs_to_jiffies() checks for the passed in value being a constant |
| * via __builtin_constant_p() allowing gcc to eliminate most of the |
| * code, __msecs_to_jiffies() is called if the value passed does not |
| * allow constant folding and the actual conversion must be done at |
| * runtime. |
| * the HZ range specific helpers _msecs_to_jiffies() are called both |
| * directly here and from __msecs_to_jiffies() in the case where |
| * constant folding is not possible. |
| */ |
| static inline unsigned long msecs_to_jiffies(const unsigned int m) |
| { |
| if (__builtin_constant_p(m)) { |
| if ((int)m < 0) |
| return MAX_JIFFY_OFFSET; |
| return _msecs_to_jiffies(m); |
| } else { |
| return __msecs_to_jiffies(m); |
| } |
| } |
| |
| extern unsigned long __usecs_to_jiffies(const unsigned int u); |
| #if !(USEC_PER_SEC % HZ) |
| static inline unsigned long _usecs_to_jiffies(const unsigned int u) |
| { |
| return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ); |
| } |
| #else |
| static inline unsigned long _usecs_to_jiffies(const unsigned int u) |
| { |
| return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32) |
| >> USEC_TO_HZ_SHR32; |
| } |
| #endif |
| |
| /** |
| * usecs_to_jiffies: - convert microseconds to jiffies |
| * @u: time in microseconds |
| * |
| * conversion is done as follows: |
| * |
| * - 'too large' values [that would result in larger than |
| * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. |
| * |
| * - all other values are converted to jiffies by either multiplying |
| * the input value by a factor or dividing it with a factor and |
| * handling any 32-bit overflows as for msecs_to_jiffies. |
| * |
| * usecs_to_jiffies() checks for the passed in value being a constant |
| * via __builtin_constant_p() allowing gcc to eliminate most of the |
| * code, __usecs_to_jiffies() is called if the value passed does not |
| * allow constant folding and the actual conversion must be done at |
| * runtime. |
| * the HZ range specific helpers _usecs_to_jiffies() are called both |
| * directly here and from __msecs_to_jiffies() in the case where |
| * constant folding is not possible. |
| */ |
| static __always_inline unsigned long usecs_to_jiffies(const unsigned int u) |
| { |
| if (__builtin_constant_p(u)) { |
| if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET)) |
| return MAX_JIFFY_OFFSET; |
| return _usecs_to_jiffies(u); |
| } else { |
| return __usecs_to_jiffies(u); |
| } |
| } |
| |
| extern unsigned long timespec64_to_jiffies(const struct timespec64 *value); |
| extern void jiffies_to_timespec64(const unsigned long jiffies, |
| struct timespec64 *value); |
| static inline unsigned long timespec_to_jiffies(const struct timespec *value) |
| { |
| struct timespec64 ts = timespec_to_timespec64(*value); |
| |
| return timespec64_to_jiffies(&ts); |
| } |
| |
| static inline void jiffies_to_timespec(const unsigned long jiffies, |
| struct timespec *value) |
| { |
| struct timespec64 ts; |
| |
| jiffies_to_timespec64(jiffies, &ts); |
| *value = timespec64_to_timespec(ts); |
| } |
| |
| extern unsigned long timeval_to_jiffies(const struct timeval *value); |
| extern void jiffies_to_timeval(const unsigned long jiffies, |
| struct timeval *value); |