Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212/* SPDX-License-Identifier: GPL-2.0 */#ifndef _LINUX_MATH_H#define _LINUX_MATH_H
#include <linux/types.h>#include <asm/div64.h>#include <uapi/linux/kernel.h>
/* * This looks more complex than it should be. But we need to * get the type for the ~ right in round_down (it needs to be * as wide as the result!), and we want to evaluate the macro * arguments just once each. */#define __round_mask(x, y) ((__typeof__(x))((y)-1))
/** * round_up - round up to next specified power of 2 * @x: the value to round * @y: multiple to round up to (must be a power of 2) * * Rounds @x up to next multiple of @y (which must be a power of 2). * To perform arbitrary rounding up, use roundup() below. */#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
/** * round_down - round down to next specified power of 2 * @x: the value to round * @y: multiple to round down to (must be a power of 2) * * Rounds @x down to next multiple of @y (which must be a power of 2). * To perform arbitrary rounding down, use rounddown() below. */#define round_down(x, y) ((x) & ~__round_mask(x, y))
/** * DIV_ROUND_UP_POW2 - divide and round up * @n: numerator * @d: denominator (must be a power of 2) * * Divides @n by @d and rounds up to next multiple of @d (which must be a power * of 2). Avoids integer overflows that may occur with __KERNEL_DIV_ROUND_UP(). * Performance is roughly equivalent to __KERNEL_DIV_ROUND_UP(). */#define DIV_ROUND_UP_POW2(n, d) \ ((n) / (d) + !!((n) & ((d) - 1)))
#define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
#define DIV_ROUND_DOWN_ULL(ll, d) \ ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })
#define DIV_ROUND_UP_ULL(ll, d) \ DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d))
#if BITS_PER_LONG == 32# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)#else# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)#endif
/** * roundup - round up to the next specified multiple * @x: the value to up * @y: multiple to round up to * * Rounds @x up to next multiple of @y. If @y will always be a power * of 2, consider using the faster round_up(). */#define roundup(x, y) ( \{ \ typeof(y) __y = y; \ (((x) + (__y - 1)) / __y) * __y; \} \)/** * rounddown - round down to next specified multiple * @x: the value to round * @y: multiple to round down to * * Rounds @x down to next multiple of @y. If @y will always be a power * of 2, consider using the faster round_down(). */#define rounddown(x, y) ( \{ \ typeof(x) __x = (x); \ __x - (__x % (y)); \} \)
#define DIV_ROUND_CLOSEST __KERNEL_DIV_ROUND_CLOSEST/* * Same as above but for u64 dividends. divisor must be a 32-bit * number. */#define DIV_ROUND_CLOSEST_ULL(x, divisor)( \{ \ typeof(divisor) __d = divisor; \ unsigned long long _tmp = (x) + (__d) / 2; \ do_div(_tmp, __d); \ _tmp; \} \)
#define __STRUCT_FRACT(type) \struct type##_fract { \ __##type numerator; \ __##type denominator; \};__STRUCT_FRACT(s8)__STRUCT_FRACT(u8)__STRUCT_FRACT(s16)__STRUCT_FRACT(u16)__STRUCT_FRACT(s32)__STRUCT_FRACT(u32)#undef __STRUCT_FRACT
/* Calculate "x * n / d" without unnecessary overflow or loss of precision. */#define mult_frac(x, n, d) \({ \ typeof(x) x_ = (x); \ typeof(n) n_ = (n); \ typeof(d) d_ = (d); \ \ typeof(x_) q = x_ / d_; \ typeof(x_) r = x_ % d_; \ q * n_ + r * n_ / d_; \})
#define sector_div(a, b) do_div(a, b)
/** * abs - return absolute value of an argument * @x: the value. * * If it is unsigned type, @x is converted to signed type first. * char is treated as if it was signed (regardless of whether it really is) * but the macro's return type is preserved as char. * * NOTE, for signed type if @x is the minimum, the returned result is undefined * as there is not enough bits to represent it as a positive number. * * Return: an absolute value of @x. */#define abs(x) __abs_choose_expr(x, long long, \ __abs_choose_expr(x, long, \ __abs_choose_expr(x, int, \ __abs_choose_expr(x, short, \ __abs_choose_expr(x, char, \ __builtin_choose_expr( \ __builtin_types_compatible_p(typeof(x), char), \ (char)({ signed char __x = (x); __x<0?-__x:__x; }), \ ((void)0)))))))
#define __abs_choose_expr(x, type, other) __builtin_choose_expr( \ __builtin_types_compatible_p(typeof(x), signed type) || \ __builtin_types_compatible_p(typeof(x), unsigned type), \ ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
/** * abs_diff - return absolute value of the difference between the arguments * @a: the first argument * @b: the second argument * * @a and @b have to be of the same type. With this restriction we compare * signed to signed and unsigned to unsigned. The result is the subtraction * the smaller of the two from the bigger, hence result is always a positive * value. * * Return: an absolute value of the difference between the @a and @b. */#define abs_diff(a, b) ({ \ typeof(a) __a = (a); \ typeof(b) __b = (b); \ (void)(&__a == &__b); \ __a > __b ? (__a - __b) : (__b - __a); \})
/** * reciprocal_scale - "scale" a value into range [0, ep_ro) * @val: value * @ep_ro: right open interval endpoint * * Perform a "reciprocal multiplication" in order to "scale" a value into * range [0, @ep_ro), where the upper interval endpoint is right-open. * This is useful, e.g. for accessing a index of an array containing * @ep_ro elements, for example. Think of it as sort of modulus, only that * the result isn't that of modulo. ;) Note that if initial input is a * small value, then result will return 0. * * Return: a result based on @val in interval [0, @ep_ro). */static inline u32 reciprocal_scale(u32 val, u32 ep_ro){ return (u32)(((u64) val * ep_ro) >> 32);}
u64 int_pow(u64 base, unsigned int exp);unsigned long int_sqrt(unsigned long);
#if BITS_PER_LONG < 64u32 int_sqrt64(u64 x);#elsestatic inline u32 int_sqrt64(u64 x){ return (u32)int_sqrt(x);}#endif
#endif /* _LINUX_MATH_H */