Contributors: 31
| Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
| Andy Shevchenko |
74 |
24.42% |
4 |
10.81% |
| Nicholas Bellinger |
33 |
10.89% |
1 |
2.70% |
| Daniel Borkmann |
30 |
9.90% |
1 |
2.70% |
| Crt Mori |
29 |
9.57% |
1 |
2.70% |
| Andi Kleen |
16 |
5.28% |
1 |
2.70% |
| Peter Rosin |
10 |
3.30% |
1 |
2.70% |
| Linus Torvalds |
10 |
3.30% |
1 |
2.70% |
| Eric Paris |
9 |
2.97% |
1 |
2.70% |
| Andrew Morton |
9 |
2.97% |
2 |
5.41% |
| Christoph Hellwig |
8 |
2.64% |
1 |
2.70% |
| Darrick J. Wong |
8 |
2.64% |
1 |
2.70% |
| Salman Qazi |
6 |
1.98% |
1 |
2.70% |
| Javi Merino |
6 |
1.98% |
1 |
2.70% |
| Damien Lespiau |
6 |
1.98% |
2 |
5.41% |
| Enric Balletbò i Serra |
6 |
1.98% |
1 |
2.70% |
| Alexey Dobriyan |
5 |
1.65% |
1 |
2.70% |
| Ingo Molnar |
4 |
1.32% |
1 |
2.70% |
| Randy Dunlap |
4 |
1.32% |
2 |
5.41% |
| U. Artie Eoff |
4 |
1.32% |
1 |
2.70% |
| David Howells |
3 |
0.99% |
1 |
2.70% |
| Steven Whitehouse |
3 |
0.99% |
1 |
2.70% |
| Akinobu Mita |
3 |
0.99% |
1 |
2.70% |
| Kees Cook |
3 |
0.99% |
1 |
2.70% |
| Roman Zippel |
2 |
0.66% |
1 |
2.70% |
| Paulo Zanoni |
2 |
0.66% |
1 |
2.70% |
| Vinod Koul |
2 |
0.66% |
1 |
2.70% |
| Bernardo Innocenti |
2 |
0.66% |
1 |
2.70% |
| Yinghai Lu |
2 |
0.66% |
1 |
2.70% |
| Jens Axboe |
2 |
0.66% |
1 |
2.70% |
| Nicolas Dichtel |
1 |
0.33% |
1 |
2.70% |
| Niklas Söderlund |
1 |
0.33% |
1 |
2.70% |
| Total |
303 |
|
37 |
|
/* 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))
#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)); \
} \
)
/*
* Divide positive or negative dividend by positive or negative divisor
* and round to closest integer. Result is undefined for negative
* divisors if the dividend variable type is unsigned and for negative
* dividends if the divisor variable type is unsigned.
*/
#define DIV_ROUND_CLOSEST(x, divisor)( \
{ \
typeof(x) __x = x; \
typeof(divisor) __d = divisor; \
(((typeof(x))-1) > 0 || \
((typeof(divisor))-1) > 0 || \
(((__x) > 0) == ((__d) > 0))) ? \
(((__x) + ((__d) / 2)) / (__d)) : \
(((__x) - ((__d) / 2)) / (__d)); \
} \
)
/*
* 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(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, it 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.
*
* 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 < 64
u32 int_sqrt64(u64 x);
#else
static inline u32 int_sqrt64(u64 x)
{
return (u32)int_sqrt(x);
}
#endif
#endif /* _LINUX_MATH_H */