LCOV - code coverage report
Current view: top level - include/linux - kernel.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 12 33 36.4 %
Date: 2022-04-01 14:35:51 Functions: 0 0 -
Branches: 2 8 25.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_KERNEL_H
       3                 :            : #define _LINUX_KERNEL_H
       4                 :            : 
       5                 :            : 
       6                 :            : #include <stdarg.h>
       7                 :            : #include <linux/limits.h>
       8                 :            : #include <linux/linkage.h>
       9                 :            : #include <linux/stddef.h>
      10                 :            : #include <linux/types.h>
      11                 :            : #include <linux/compiler.h>
      12                 :            : #include <linux/bitops.h>
      13                 :            : #include <linux/log2.h>
      14                 :            : #include <linux/typecheck.h>
      15                 :            : #include <linux/printk.h>
      16                 :            : #include <linux/build_bug.h>
      17                 :            : #include <asm/byteorder.h>
      18                 :            : #include <asm/div64.h>
      19                 :            : #include <uapi/linux/kernel.h>
      20                 :            : #include <asm/div64.h>
      21                 :            : 
      22                 :            : #define STACK_MAGIC     0xdeadbeef
      23                 :            : 
      24                 :            : /**
      25                 :            :  * REPEAT_BYTE - repeat the value @x multiple times as an unsigned long value
      26                 :            :  * @x: value to repeat
      27                 :            :  *
      28                 :            :  * NOTE: @x is not checked for > 0xff; larger values produce odd results.
      29                 :            :  */
      30                 :            : #define REPEAT_BYTE(x)  ((~0ul / 0xff) * (x))
      31                 :            : 
      32                 :            : /* @a is a power of 2 value */
      33                 :            : #define ALIGN(x, a)             __ALIGN_KERNEL((x), (a))
      34                 :            : #define ALIGN_DOWN(x, a)        __ALIGN_KERNEL((x) - ((a) - 1), (a))
      35                 :            : #define __ALIGN_MASK(x, mask)   __ALIGN_KERNEL_MASK((x), (mask))
      36                 :            : #define PTR_ALIGN(p, a)         ((typeof(p))ALIGN((unsigned long)(p), (a)))
      37                 :            : #define IS_ALIGNED(x, a)                (((x) & ((typeof(x))(a) - 1)) == 0)
      38                 :            : 
      39                 :            : /* generic data direction definitions */
      40                 :            : #define READ                    0
      41                 :            : #define WRITE                   1
      42                 :            : 
      43                 :            : /**
      44                 :            :  * ARRAY_SIZE - get the number of elements in array @arr
      45                 :            :  * @arr: array to be sized
      46                 :            :  */
      47                 :            : #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
      48                 :            : 
      49                 :            : #define u64_to_user_ptr(x) (            \
      50                 :            : {                                       \
      51                 :            :         typecheck(u64, (x));            \
      52                 :            :         (void __user *)(uintptr_t)(x);  \
      53                 :            : }                                       \
      54                 :            : )
      55                 :            : 
      56                 :            : /*
      57                 :            :  * This looks more complex than it should be. But we need to
      58                 :            :  * get the type for the ~ right in round_down (it needs to be
      59                 :            :  * as wide as the result!), and we want to evaluate the macro
      60                 :            :  * arguments just once each.
      61                 :            :  */
      62                 :            : #define __round_mask(x, y) ((__typeof__(x))((y)-1))
      63                 :            : /**
      64                 :            :  * round_up - round up to next specified power of 2
      65                 :            :  * @x: the value to round
      66                 :            :  * @y: multiple to round up to (must be a power of 2)
      67                 :            :  *
      68                 :            :  * Rounds @x up to next multiple of @y (which must be a power of 2).
      69                 :            :  * To perform arbitrary rounding up, use roundup() below.
      70                 :            :  */
      71                 :            : #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
      72                 :            : /**
      73                 :            :  * round_down - round down to next specified power of 2
      74                 :            :  * @x: the value to round
      75                 :            :  * @y: multiple to round down to (must be a power of 2)
      76                 :            :  *
      77                 :            :  * Rounds @x down to next multiple of @y (which must be a power of 2).
      78                 :            :  * To perform arbitrary rounding down, use rounddown() below.
      79                 :            :  */
      80                 :            : #define round_down(x, y) ((x) & ~__round_mask(x, y))
      81                 :            : 
      82                 :            : #define typeof_member(T, m)     typeof(((T*)0)->m)
      83                 :            : 
      84                 :            : #define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
      85                 :            : 
      86                 :            : #define DIV_ROUND_DOWN_ULL(ll, d) \
      87                 :            :         ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })
      88                 :            : 
      89                 :            : #define DIV_ROUND_UP_ULL(ll, d) \
      90                 :            :         DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d))
      91                 :            : 
      92                 :            : #if BITS_PER_LONG == 32
      93                 :            : # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
      94                 :            : #else
      95                 :            : # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
      96                 :            : #endif
      97                 :            : 
      98                 :            : /**
      99                 :            :  * roundup - round up to the next specified multiple
     100                 :            :  * @x: the value to up
     101                 :            :  * @y: multiple to round up to
     102                 :            :  *
     103                 :            :  * Rounds @x up to next multiple of @y. If @y will always be a power
     104                 :            :  * of 2, consider using the faster round_up().
     105                 :            :  */
     106                 :            : #define roundup(x, y) (                                 \
     107                 :            : {                                                       \
     108                 :            :         typeof(y) __y = y;                              \
     109                 :            :         (((x) + (__y - 1)) / __y) * __y;                \
     110                 :            : }                                                       \
     111                 :            : )
     112                 :            : /**
     113                 :            :  * rounddown - round down to next specified multiple
     114                 :            :  * @x: the value to round
     115                 :            :  * @y: multiple to round down to
     116                 :            :  *
     117                 :            :  * Rounds @x down to next multiple of @y. If @y will always be a power
     118                 :            :  * of 2, consider using the faster round_down().
     119                 :            :  */
     120                 :            : #define rounddown(x, y) (                               \
     121                 :            : {                                                       \
     122                 :            :         typeof(x) __x = (x);                            \
     123                 :            :         __x - (__x % (y));                              \
     124                 :            : }                                                       \
     125                 :            : )
     126                 :            : 
     127                 :            : /*
     128                 :            :  * Divide positive or negative dividend by positive or negative divisor
     129                 :            :  * and round to closest integer. Result is undefined for negative
     130                 :            :  * divisors if the dividend variable type is unsigned and for negative
     131                 :            :  * dividends if the divisor variable type is unsigned.
     132                 :            :  */
     133                 :            : #define DIV_ROUND_CLOSEST(x, divisor)(                  \
     134                 :            : {                                                       \
     135                 :            :         typeof(x) __x = x;                              \
     136                 :            :         typeof(divisor) __d = divisor;                  \
     137                 :            :         (((typeof(x))-1) > 0 ||                              \
     138                 :            :          ((typeof(divisor))-1) > 0 ||                        \
     139                 :            :          (((__x) > 0) == ((__d) > 0))) ?          \
     140                 :            :                 (((__x) + ((__d) / 2)) / (__d)) :       \
     141                 :            :                 (((__x) - ((__d) / 2)) / (__d));        \
     142                 :            : }                                                       \
     143                 :            : )
     144                 :            : /*
     145                 :            :  * Same as above but for u64 dividends. divisor must be a 32-bit
     146                 :            :  * number.
     147                 :            :  */
     148                 :            : #define DIV_ROUND_CLOSEST_ULL(x, divisor)(              \
     149                 :            : {                                                       \
     150                 :            :         typeof(divisor) __d = divisor;                  \
     151                 :            :         unsigned long long _tmp = (x) + (__d) / 2;      \
     152                 :            :         do_div(_tmp, __d);                              \
     153                 :            :         _tmp;                                           \
     154                 :            : }                                                       \
     155                 :            : )
     156                 :            : 
     157                 :            : /*
     158                 :            :  * Multiplies an integer by a fraction, while avoiding unnecessary
     159                 :            :  * overflow or loss of precision.
     160                 :            :  */
     161                 :            : #define mult_frac(x, numer, denom)(                     \
     162                 :            : {                                                       \
     163                 :            :         typeof(x) quot = (x) / (denom);                 \
     164                 :            :         typeof(x) rem  = (x) % (denom);                 \
     165                 :            :         (quot * (numer)) + ((rem * (numer)) / (denom)); \
     166                 :            : }                                                       \
     167                 :            : )
     168                 :            : 
     169                 :            : 
     170                 :            : #define _RET_IP_                (unsigned long)__builtin_return_address(0)
     171                 :            : #define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
     172                 :            : 
     173                 :            : #define sector_div(a, b) do_div(a, b)
     174                 :            : 
     175                 :            : /**
     176                 :            :  * upper_32_bits - return bits 32-63 of a number
     177                 :            :  * @n: the number we're accessing
     178                 :            :  *
     179                 :            :  * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress
     180                 :            :  * the "right shift count >= width of type" warning when that quantity is
     181                 :            :  * 32-bits.
     182                 :            :  */
     183                 :            : #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
     184                 :            : 
     185                 :            : /**
     186                 :            :  * lower_32_bits - return bits 0-31 of a number
     187                 :            :  * @n: the number we're accessing
     188                 :            :  */
     189                 :            : #define lower_32_bits(n) ((u32)(n))
     190                 :            : 
     191                 :            : struct completion;
     192                 :            : struct pt_regs;
     193                 :            : struct user;
     194                 :            : 
     195                 :            : #ifdef CONFIG_PREEMPT_VOLUNTARY
     196                 :            : extern int _cond_resched(void);
     197                 :            : # define might_resched() _cond_resched()
     198                 :            : #else
     199                 :            : # define might_resched() do { } while (0)
     200                 :            : #endif
     201                 :            : 
     202                 :            : #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
     203                 :            : extern void ___might_sleep(const char *file, int line, int preempt_offset);
     204                 :            : extern void __might_sleep(const char *file, int line, int preempt_offset);
     205                 :            : extern void __cant_sleep(const char *file, int line, int preempt_offset);
     206                 :            : 
     207                 :            : /**
     208                 :            :  * might_sleep - annotation for functions that can sleep
     209                 :            :  *
     210                 :            :  * this macro will print a stack trace if it is executed in an atomic
     211                 :            :  * context (spinlock, irq-handler, ...). Additional sections where blocking is
     212                 :            :  * not allowed can be annotated with non_block_start() and non_block_end()
     213                 :            :  * pairs.
     214                 :            :  *
     215                 :            :  * This is a useful debugging help to be able to catch problems early and not
     216                 :            :  * be bitten later when the calling function happens to sleep when it is not
     217                 :            :  * supposed to.
     218                 :            :  */
     219                 :            : # define might_sleep() \
     220                 :            :         do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
     221                 :            : /**
     222                 :            :  * cant_sleep - annotation for functions that cannot sleep
     223                 :            :  *
     224                 :            :  * this macro will print a stack trace if it is executed with preemption enabled
     225                 :            :  */
     226                 :            : # define cant_sleep() \
     227                 :            :         do { __cant_sleep(__FILE__, __LINE__, 0); } while (0)
     228                 :            : # define sched_annotate_sleep() (current->task_state_change = 0)
     229                 :            : /**
     230                 :            :  * non_block_start - annotate the start of section where sleeping is prohibited
     231                 :            :  *
     232                 :            :  * This is on behalf of the oom reaper, specifically when it is calling the mmu
     233                 :            :  * notifiers. The problem is that if the notifier were to block on, for example,
     234                 :            :  * mutex_lock() and if the process which holds that mutex were to perform a
     235                 :            :  * sleeping memory allocation, the oom reaper is now blocked on completion of
     236                 :            :  * that memory allocation. Other blocking calls like wait_event() pose similar
     237                 :            :  * issues.
     238                 :            :  */
     239                 :            : # define non_block_start() (current->non_block_count++)
     240                 :            : /**
     241                 :            :  * non_block_end - annotate the end of section where sleeping is prohibited
     242                 :            :  *
     243                 :            :  * Closes a section opened by non_block_start().
     244                 :            :  */
     245                 :            : # define non_block_end() WARN_ON(current->non_block_count-- == 0)
     246                 :            : #else
     247                 :    7319911 :   static inline void ___might_sleep(const char *file, int line,
     248                 :    7319911 :                                    int preempt_offset) { }
     249                 :            :   static inline void __might_sleep(const char *file, int line,
     250                 :            :                                    int preempt_offset) { }
     251                 :            : # define might_sleep() do { might_resched(); } while (0)
     252                 :            : # define cant_sleep() do { } while (0)
     253                 :            : # define sched_annotate_sleep() do { } while (0)
     254                 :            : # define non_block_start() do { } while (0)
     255                 :            : # define non_block_end() do { } while (0)
     256                 :            : #endif
     257                 :            : 
     258                 :            : #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
     259                 :            : 
     260                 :            : /**
     261                 :            :  * abs - return absolute value of an argument
     262                 :            :  * @x: the value.  If it is unsigned type, it is converted to signed type first.
     263                 :            :  *     char is treated as if it was signed (regardless of whether it really is)
     264                 :            :  *     but the macro's return type is preserved as char.
     265                 :            :  *
     266                 :            :  * Return: an absolute value of x.
     267                 :            :  */
     268                 :            : #define abs(x)  __abs_choose_expr(x, long long,                         \
     269                 :            :                 __abs_choose_expr(x, long,                              \
     270                 :            :                 __abs_choose_expr(x, int,                               \
     271                 :            :                 __abs_choose_expr(x, short,                             \
     272                 :            :                 __abs_choose_expr(x, char,                              \
     273                 :            :                 __builtin_choose_expr(                                  \
     274                 :            :                         __builtin_types_compatible_p(typeof(x), char),  \
     275                 :            :                         (char)({ signed char __x = (x); __x<0?-__x:__x; }), \
     276                 :            :                         ((void)0)))))))
     277                 :            : 
     278                 :            : #define __abs_choose_expr(x, type, other) __builtin_choose_expr(        \
     279                 :            :         __builtin_types_compatible_p(typeof(x),   signed type) ||       \
     280                 :            :         __builtin_types_compatible_p(typeof(x), unsigned type),         \
     281                 :            :         ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
     282                 :            : 
     283                 :            : /**
     284                 :            :  * reciprocal_scale - "scale" a value into range [0, ep_ro)
     285                 :            :  * @val: value
     286                 :            :  * @ep_ro: right open interval endpoint
     287                 :            :  *
     288                 :            :  * Perform a "reciprocal multiplication" in order to "scale" a value into
     289                 :            :  * range [0, @ep_ro), where the upper interval endpoint is right-open.
     290                 :            :  * This is useful, e.g. for accessing a index of an array containing
     291                 :            :  * @ep_ro elements, for example. Think of it as sort of modulus, only that
     292                 :            :  * the result isn't that of modulo. ;) Note that if initial input is a
     293                 :            :  * small value, then result will return 0.
     294                 :            :  *
     295                 :            :  * Return: a result based on @val in interval [0, @ep_ro).
     296                 :            :  */
     297                 :       1848 : static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
     298                 :            : {
     299                 :       1848 :         return (u32)(((u64) val * ep_ro) >> 32);
     300                 :            : }
     301                 :            : 
     302                 :            : #if defined(CONFIG_MMU) && \
     303                 :            :         (defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP))
     304                 :            : #define might_fault() __might_fault(__FILE__, __LINE__)
     305                 :            : void __might_fault(const char *file, int line);
     306                 :            : #else
     307   [ -  +  -  + ]:    4717264 : static inline void might_fault(void) { }
     308                 :            : #endif
     309                 :            : 
     310                 :            : extern struct atomic_notifier_head panic_notifier_list;
     311                 :            : extern long (*panic_blink)(int state);
     312                 :            : __printf(1, 2)
     313                 :            : void panic(const char *fmt, ...) __noreturn __cold;
     314                 :            : void nmi_panic(struct pt_regs *regs, const char *msg);
     315                 :            : extern void oops_enter(void);
     316                 :            : extern void oops_exit(void);
     317                 :            : void print_oops_end_marker(void);
     318                 :            : extern int oops_may_print(void);
     319                 :            : void do_exit(long error_code) __noreturn;
     320                 :            : void complete_and_exit(struct completion *, long) __noreturn;
     321                 :            : 
     322                 :            : /* Internal, do not use. */
     323                 :            : int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);
     324                 :            : int __must_check _kstrtol(const char *s, unsigned int base, long *res);
     325                 :            : 
     326                 :            : int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res);
     327                 :            : int __must_check kstrtoll(const char *s, unsigned int base, long long *res);
     328                 :            : 
     329                 :            : /**
     330                 :            :  * kstrtoul - convert a string to an unsigned long
     331                 :            :  * @s: The start of the string. The string must be null-terminated, and may also
     332                 :            :  *  include a single newline before its terminating null. The first character
     333                 :            :  *  may also be a plus sign, but not a minus sign.
     334                 :            :  * @base: The number base to use. The maximum supported base is 16. If base is
     335                 :            :  *  given as 0, then the base of the string is automatically detected with the
     336                 :            :  *  conventional semantics - If it begins with 0x the number will be parsed as a
     337                 :            :  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
     338                 :            :  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
     339                 :            :  * @res: Where to write the result of the conversion on success.
     340                 :            :  *
     341                 :            :  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
     342                 :            :  * Used as a replacement for the simple_strtoull. Return code must be checked.
     343                 :            : */
     344                 :         42 : static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
     345                 :            : {
     346                 :            :         /*
     347                 :            :          * We want to shortcut function call, but
     348                 :            :          * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0.
     349                 :            :          */
     350                 :         42 :         if (sizeof(unsigned long) == sizeof(unsigned long long) &&
     351                 :            :             __alignof__(unsigned long) == __alignof__(unsigned long long))
     352         [ #  # ]:         42 :                 return kstrtoull(s, base, (unsigned long long *)res);
     353                 :            :         else
     354                 :            :                 return _kstrtoul(s, base, res);
     355                 :            : }
     356                 :            : 
     357                 :            : /**
     358                 :            :  * kstrtol - convert a string to a long
     359                 :            :  * @s: The start of the string. The string must be null-terminated, and may also
     360                 :            :  *  include a single newline before its terminating null. The first character
     361                 :            :  *  may also be a plus sign or a minus sign.
     362                 :            :  * @base: The number base to use. The maximum supported base is 16. If base is
     363                 :            :  *  given as 0, then the base of the string is automatically detected with the
     364                 :            :  *  conventional semantics - If it begins with 0x the number will be parsed as a
     365                 :            :  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
     366                 :            :  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
     367                 :            :  * @res: Where to write the result of the conversion on success.
     368                 :            :  *
     369                 :            :  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
     370                 :            :  * Used as a replacement for the simple_strtoull. Return code must be checked.
     371                 :            :  */
     372                 :          0 : static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
     373                 :            : {
     374                 :            :         /*
     375                 :            :          * We want to shortcut function call, but
     376                 :            :          * __builtin_types_compatible_p(long, long long) = 0.
     377                 :            :          */
     378                 :          0 :         if (sizeof(long) == sizeof(long long) &&
     379                 :            :             __alignof__(long) == __alignof__(long long))
     380                 :          0 :                 return kstrtoll(s, base, (long long *)res);
     381                 :            :         else
     382                 :            :                 return _kstrtol(s, base, res);
     383                 :            : }
     384                 :            : 
     385                 :            : int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res);
     386                 :            : int __must_check kstrtoint(const char *s, unsigned int base, int *res);
     387                 :            : 
     388                 :          0 : static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res)
     389                 :            : {
     390                 :          0 :         return kstrtoull(s, base, res);
     391                 :            : }
     392                 :            : 
     393                 :          0 : static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res)
     394                 :            : {
     395                 :          0 :         return kstrtoll(s, base, res);
     396                 :            : }
     397                 :            : 
     398                 :          0 : static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res)
     399                 :            : {
     400                 :          0 :         return kstrtouint(s, base, res);
     401                 :            : }
     402                 :            : 
     403                 :          0 : static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res)
     404                 :            : {
     405                 :          0 :         return kstrtoint(s, base, res);
     406                 :            : }
     407                 :            : 
     408                 :            : int __must_check kstrtou16(const char *s, unsigned int base, u16 *res);
     409                 :            : int __must_check kstrtos16(const char *s, unsigned int base, s16 *res);
     410                 :            : int __must_check kstrtou8(const char *s, unsigned int base, u8 *res);
     411                 :            : int __must_check kstrtos8(const char *s, unsigned int base, s8 *res);
     412                 :            : int __must_check kstrtobool(const char *s, bool *res);
     413                 :            : 
     414                 :            : int __must_check kstrtoull_from_user(const char __user *s, size_t count, unsigned int base, unsigned long long *res);
     415                 :            : int __must_check kstrtoll_from_user(const char __user *s, size_t count, unsigned int base, long long *res);
     416                 :            : int __must_check kstrtoul_from_user(const char __user *s, size_t count, unsigned int base, unsigned long *res);
     417                 :            : int __must_check kstrtol_from_user(const char __user *s, size_t count, unsigned int base, long *res);
     418                 :            : int __must_check kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res);
     419                 :            : int __must_check kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, int *res);
     420                 :            : int __must_check kstrtou16_from_user(const char __user *s, size_t count, unsigned int base, u16 *res);
     421                 :            : int __must_check kstrtos16_from_user(const char __user *s, size_t count, unsigned int base, s16 *res);
     422                 :            : int __must_check kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, u8 *res);
     423                 :            : int __must_check kstrtos8_from_user(const char __user *s, size_t count, unsigned int base, s8 *res);
     424                 :            : int __must_check kstrtobool_from_user(const char __user *s, size_t count, bool *res);
     425                 :            : 
     426                 :          0 : static inline int __must_check kstrtou64_from_user(const char __user *s, size_t count, unsigned int base, u64 *res)
     427                 :            : {
     428                 :          0 :         return kstrtoull_from_user(s, count, base, res);
     429                 :            : }
     430                 :            : 
     431                 :            : static inline int __must_check kstrtos64_from_user(const char __user *s, size_t count, unsigned int base, s64 *res)
     432                 :            : {
     433                 :            :         return kstrtoll_from_user(s, count, base, res);
     434                 :            : }
     435                 :            : 
     436                 :          0 : static inline int __must_check kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, u32 *res)
     437                 :            : {
     438                 :          0 :         return kstrtouint_from_user(s, count, base, res);
     439                 :            : }
     440                 :            : 
     441                 :          0 : static inline int __must_check kstrtos32_from_user(const char __user *s, size_t count, unsigned int base, s32 *res)
     442                 :            : {
     443                 :          0 :         return kstrtoint_from_user(s, count, base, res);
     444                 :            : }
     445                 :            : 
     446                 :            : /*
     447                 :            :  * Use kstrto<foo> instead.
     448                 :            :  *
     449                 :            :  * NOTE: simple_strto<foo> does not check for the range overflow and,
     450                 :            :  *       depending on the input, may give interesting results.
     451                 :            :  *
     452                 :            :  * Use these functions if and only if you cannot use kstrto<foo>, because
     453                 :            :  * the conversion ends on the first non-digit character, which may be far
     454                 :            :  * beyond the supported range. It might be useful to parse the strings like
     455                 :            :  * 10x50 or 12:21 without altering original string or temporary buffer in use.
     456                 :            :  * Keep in mind above caveat.
     457                 :            :  */
     458                 :            : 
     459                 :            : extern unsigned long simple_strtoul(const char *,char **,unsigned int);
     460                 :            : extern long simple_strtol(const char *,char **,unsigned int);
     461                 :            : extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
     462                 :            : extern long long simple_strtoll(const char *,char **,unsigned int);
     463                 :            : 
     464                 :            : extern int num_to_str(char *buf, int size,
     465                 :            :                       unsigned long long num, unsigned int width);
     466                 :            : 
     467                 :            : /* lib/printf utilities */
     468                 :            : 
     469                 :            : extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
     470                 :            : extern __printf(2, 0) int vsprintf(char *buf, const char *, va_list);
     471                 :            : extern __printf(3, 4)
     472                 :            : int snprintf(char *buf, size_t size, const char *fmt, ...);
     473                 :            : extern __printf(3, 0)
     474                 :            : int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
     475                 :            : extern __printf(3, 4)
     476                 :            : int scnprintf(char *buf, size_t size, const char *fmt, ...);
     477                 :            : extern __printf(3, 0)
     478                 :            : int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
     479                 :            : extern __printf(2, 3) __malloc
     480                 :            : char *kasprintf(gfp_t gfp, const char *fmt, ...);
     481                 :            : extern __printf(2, 0) __malloc
     482                 :            : char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
     483                 :            : extern __printf(2, 0)
     484                 :            : const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);
     485                 :            : 
     486                 :            : extern __scanf(2, 3)
     487                 :            : int sscanf(const char *, const char *, ...);
     488                 :            : extern __scanf(2, 0)
     489                 :            : int vsscanf(const char *, const char *, va_list);
     490                 :            : 
     491                 :            : extern int get_option(char **str, int *pint);
     492                 :            : extern char *get_options(const char *str, int nints, int *ints);
     493                 :            : extern unsigned long long memparse(const char *ptr, char **retptr);
     494                 :            : extern bool parse_option_str(const char *str, const char *option);
     495                 :            : extern char *next_arg(char *args, char **param, char **val);
     496                 :            : 
     497                 :            : extern int core_kernel_text(unsigned long addr);
     498                 :            : extern int init_kernel_text(unsigned long addr);
     499                 :            : extern int core_kernel_data(unsigned long addr);
     500                 :            : extern int __kernel_text_address(unsigned long addr);
     501                 :            : extern int kernel_text_address(unsigned long addr);
     502                 :            : extern int func_ptr_is_kernel_text(void *ptr);
     503                 :            : 
     504                 :            : u64 int_pow(u64 base, unsigned int exp);
     505                 :            : unsigned long int_sqrt(unsigned long);
     506                 :            : 
     507                 :            : #if BITS_PER_LONG < 64
     508                 :            : u32 int_sqrt64(u64 x);
     509                 :            : #else
     510                 :            : static inline u32 int_sqrt64(u64 x)
     511                 :            : {
     512                 :            :         return (u32)int_sqrt(x);
     513                 :            : }
     514                 :            : #endif
     515                 :            : 
     516                 :            : extern void bust_spinlocks(int yes);
     517                 :            : extern int oops_in_progress;            /* If set, an oops, panic(), BUG() or die() is in progress */
     518                 :            : extern int panic_timeout;
     519                 :            : extern unsigned long panic_print;
     520                 :            : extern int panic_on_oops;
     521                 :            : extern int panic_on_unrecovered_nmi;
     522                 :            : extern int panic_on_io_nmi;
     523                 :            : extern int panic_on_warn;
     524                 :            : extern int sysctl_panic_on_rcu_stall;
     525                 :            : extern int sysctl_panic_on_stackoverflow;
     526                 :            : 
     527                 :            : extern bool crash_kexec_post_notifiers;
     528                 :            : 
     529                 :            : /*
     530                 :            :  * panic_cpu is used for synchronizing panic() and crash_kexec() execution. It
     531                 :            :  * holds a CPU number which is executing panic() currently. A value of
     532                 :            :  * PANIC_CPU_INVALID means no CPU has entered panic() or crash_kexec().
     533                 :            :  */
     534                 :            : extern atomic_t panic_cpu;
     535                 :            : #define PANIC_CPU_INVALID       -1
     536                 :            : 
     537                 :            : /*
     538                 :            :  * Only to be used by arch init code. If the user over-wrote the default
     539                 :            :  * CONFIG_PANIC_TIMEOUT, honor it.
     540                 :            :  */
     541                 :            : static inline void set_arch_panic_timeout(int timeout, int arch_default_timeout)
     542                 :            : {
     543                 :            :         if (panic_timeout == arch_default_timeout)
     544                 :            :                 panic_timeout = timeout;
     545                 :            : }
     546                 :            : extern const char *print_tainted(void);
     547                 :            : enum lockdep_ok {
     548                 :            :         LOCKDEP_STILL_OK,
     549                 :            :         LOCKDEP_NOW_UNRELIABLE
     550                 :            : };
     551                 :            : extern void add_taint(unsigned flag, enum lockdep_ok);
     552                 :            : extern int test_taint(unsigned flag);
     553                 :            : extern unsigned long get_taint(void);
     554                 :            : extern int root_mountflags;
     555                 :            : 
     556                 :            : extern bool early_boot_irqs_disabled;
     557                 :            : 
     558                 :            : /*
     559                 :            :  * Values used for system_state. Ordering of the states must not be changed
     560                 :            :  * as code checks for <, <=, >, >= STATE.
     561                 :            :  */
     562                 :            : extern enum system_states {
     563                 :            :         SYSTEM_BOOTING,
     564                 :            :         SYSTEM_SCHEDULING,
     565                 :            :         SYSTEM_RUNNING,
     566                 :            :         SYSTEM_HALT,
     567                 :            :         SYSTEM_POWER_OFF,
     568                 :            :         SYSTEM_RESTART,
     569                 :            :         SYSTEM_SUSPEND,
     570                 :            : } system_state;
     571                 :            : 
     572                 :            : /* This cannot be an enum because some may be used in assembly source. */
     573                 :            : #define TAINT_PROPRIETARY_MODULE        0
     574                 :            : #define TAINT_FORCED_MODULE             1
     575                 :            : #define TAINT_CPU_OUT_OF_SPEC           2
     576                 :            : #define TAINT_FORCED_RMMOD              3
     577                 :            : #define TAINT_MACHINE_CHECK             4
     578                 :            : #define TAINT_BAD_PAGE                  5
     579                 :            : #define TAINT_USER                      6
     580                 :            : #define TAINT_DIE                       7
     581                 :            : #define TAINT_OVERRIDDEN_ACPI_TABLE     8
     582                 :            : #define TAINT_WARN                      9
     583                 :            : #define TAINT_CRAP                      10
     584                 :            : #define TAINT_FIRMWARE_WORKAROUND       11
     585                 :            : #define TAINT_OOT_MODULE                12
     586                 :            : #define TAINT_UNSIGNED_MODULE           13
     587                 :            : #define TAINT_SOFTLOCKUP                14
     588                 :            : #define TAINT_LIVEPATCH                 15
     589                 :            : #define TAINT_AUX                       16
     590                 :            : #define TAINT_RANDSTRUCT                17
     591                 :            : #define TAINT_FLAGS_COUNT               18
     592                 :            : 
     593                 :            : struct taint_flag {
     594                 :            :         char c_true;    /* character printed when tainted */
     595                 :            :         char c_false;   /* character printed when not tainted */
     596                 :            :         bool module;    /* also show as a per-module taint flag */
     597                 :            : };
     598                 :            : 
     599                 :            : extern const struct taint_flag taint_flags[TAINT_FLAGS_COUNT];
     600                 :            : 
     601                 :            : extern const char hex_asc[];
     602                 :            : #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
     603                 :            : #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
     604                 :            : 
     605                 :       4347 : static inline char *hex_byte_pack(char *buf, u8 byte)
     606                 :            : {
     607                 :       4347 :         *buf++ = hex_asc_hi(byte);
     608                 :       4347 :         *buf++ = hex_asc_lo(byte);
     609         [ -  - ]:       4347 :         return buf;
     610                 :            : }
     611                 :            : 
     612                 :            : extern const char hex_asc_upper[];
     613                 :            : #define hex_asc_upper_lo(x)     hex_asc_upper[((x) & 0x0f)]
     614                 :            : #define hex_asc_upper_hi(x)     hex_asc_upper[((x) & 0xf0) >> 4]
     615                 :            : 
     616                 :          0 : static inline char *hex_byte_pack_upper(char *buf, u8 byte)
     617                 :            : {
     618                 :          0 :         *buf++ = hex_asc_upper_hi(byte);
     619                 :          0 :         *buf++ = hex_asc_upper_lo(byte);
     620                 :          0 :         return buf;
     621                 :            : }
     622                 :            : 
     623                 :            : extern int hex_to_bin(char ch);
     624                 :            : extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
     625                 :            : extern char *bin2hex(char *dst, const void *src, size_t count);
     626                 :            : 
     627                 :            : bool mac_pton(const char *s, u8 *mac);
     628                 :            : 
     629                 :            : /*
     630                 :            :  * General tracing related utility functions - trace_printk(),
     631                 :            :  * tracing_on/tracing_off and tracing_start()/tracing_stop
     632                 :            :  *
     633                 :            :  * Use tracing_on/tracing_off when you want to quickly turn on or off
     634                 :            :  * tracing. It simply enables or disables the recording of the trace events.
     635                 :            :  * This also corresponds to the user space /sys/kernel/debug/tracing/tracing_on
     636                 :            :  * file, which gives a means for the kernel and userspace to interact.
     637                 :            :  * Place a tracing_off() in the kernel where you want tracing to end.
     638                 :            :  * From user space, examine the trace, and then echo 1 > tracing_on
     639                 :            :  * to continue tracing.
     640                 :            :  *
     641                 :            :  * tracing_stop/tracing_start has slightly more overhead. It is used
     642                 :            :  * by things like suspend to ram where disabling the recording of the
     643                 :            :  * trace is not enough, but tracing must actually stop because things
     644                 :            :  * like calling smp_processor_id() may crash the system.
     645                 :            :  *
     646                 :            :  * Most likely, you want to use tracing_on/tracing_off.
     647                 :            :  */
     648                 :            : 
     649                 :            : enum ftrace_dump_mode {
     650                 :            :         DUMP_NONE,
     651                 :            :         DUMP_ALL,
     652                 :            :         DUMP_ORIG,
     653                 :            : };
     654                 :            : 
     655                 :            : #ifdef CONFIG_TRACING
     656                 :            : void tracing_on(void);
     657                 :            : void tracing_off(void);
     658                 :            : int tracing_is_on(void);
     659                 :            : void tracing_snapshot(void);
     660                 :            : void tracing_snapshot_alloc(void);
     661                 :            : 
     662                 :            : extern void tracing_start(void);
     663                 :            : extern void tracing_stop(void);
     664                 :            : 
     665                 :            : static inline __printf(1, 2)
     666                 :            : void ____trace_printk_check_format(const char *fmt, ...)
     667                 :            : {
     668                 :            : }
     669                 :            : #define __trace_printk_check_format(fmt, args...)                       \
     670                 :            : do {                                                                    \
     671                 :            :         if (0)                                                          \
     672                 :            :                 ____trace_printk_check_format(fmt, ##args);             \
     673                 :            : } while (0)
     674                 :            : 
     675                 :            : /**
     676                 :            :  * trace_printk - printf formatting in the ftrace buffer
     677                 :            :  * @fmt: the printf format for printing
     678                 :            :  *
     679                 :            :  * Note: __trace_printk is an internal function for trace_printk() and
     680                 :            :  *       the @ip is passed in via the trace_printk() macro.
     681                 :            :  *
     682                 :            :  * This function allows a kernel developer to debug fast path sections
     683                 :            :  * that printk is not appropriate for. By scattering in various
     684                 :            :  * printk like tracing in the code, a developer can quickly see
     685                 :            :  * where problems are occurring.
     686                 :            :  *
     687                 :            :  * This is intended as a debugging tool for the developer only.
     688                 :            :  * Please refrain from leaving trace_printks scattered around in
     689                 :            :  * your code. (Extra memory is used for special buffers that are
     690                 :            :  * allocated when trace_printk() is used.)
     691                 :            :  *
     692                 :            :  * A little optimization trick is done here. If there's only one
     693                 :            :  * argument, there's no need to scan the string for printf formats.
     694                 :            :  * The trace_puts() will suffice. But how can we take advantage of
     695                 :            :  * using trace_puts() when trace_printk() has only one argument?
     696                 :            :  * By stringifying the args and checking the size we can tell
     697                 :            :  * whether or not there are args. __stringify((__VA_ARGS__)) will
     698                 :            :  * turn into "()\0" with a size of 3 when there are no args, anything
     699                 :            :  * else will be bigger. All we need to do is define a string to this,
     700                 :            :  * and then take its size and compare to 3. If it's bigger, use
     701                 :            :  * do_trace_printk() otherwise, optimize it to trace_puts(). Then just
     702                 :            :  * let gcc optimize the rest.
     703                 :            :  */
     704                 :            : 
     705                 :            : #define trace_printk(fmt, ...)                          \
     706                 :            : do {                                                    \
     707                 :            :         char _______STR[] = __stringify((__VA_ARGS__)); \
     708                 :            :         if (sizeof(_______STR) > 3)                  \
     709                 :            :                 do_trace_printk(fmt, ##__VA_ARGS__);    \
     710                 :            :         else                                            \
     711                 :            :                 trace_puts(fmt);                        \
     712                 :            : } while (0)
     713                 :            : 
     714                 :            : #define do_trace_printk(fmt, args...)                                   \
     715                 :            : do {                                                                    \
     716                 :            :         static const char *trace_printk_fmt __used                      \
     717                 :            :                 __attribute__((section("__trace_printk_fmt"))) =      \
     718                 :            :                 __builtin_constant_p(fmt) ? fmt : NULL;                 \
     719                 :            :                                                                         \
     720                 :            :         __trace_printk_check_format(fmt, ##args);                       \
     721                 :            :                                                                         \
     722                 :            :         if (__builtin_constant_p(fmt))                                  \
     723                 :            :                 __trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args);   \
     724                 :            :         else                                                            \
     725                 :            :                 __trace_printk(_THIS_IP_, fmt, ##args);                 \
     726                 :            : } while (0)
     727                 :            : 
     728                 :            : extern __printf(2, 3)
     729                 :            : int __trace_bprintk(unsigned long ip, const char *fmt, ...);
     730                 :            : 
     731                 :            : extern __printf(2, 3)
     732                 :            : int __trace_printk(unsigned long ip, const char *fmt, ...);
     733                 :            : 
     734                 :            : /**
     735                 :            :  * trace_puts - write a string into the ftrace buffer
     736                 :            :  * @str: the string to record
     737                 :            :  *
     738                 :            :  * Note: __trace_bputs is an internal function for trace_puts and
     739                 :            :  *       the @ip is passed in via the trace_puts macro.
     740                 :            :  *
     741                 :            :  * This is similar to trace_printk() but is made for those really fast
     742                 :            :  * paths that a developer wants the least amount of "Heisenbug" effects,
     743                 :            :  * where the processing of the print format is still too much.
     744                 :            :  *
     745                 :            :  * This function allows a kernel developer to debug fast path sections
     746                 :            :  * that printk is not appropriate for. By scattering in various
     747                 :            :  * printk like tracing in the code, a developer can quickly see
     748                 :            :  * where problems are occurring.
     749                 :            :  *
     750                 :            :  * This is intended as a debugging tool for the developer only.
     751                 :            :  * Please refrain from leaving trace_puts scattered around in
     752                 :            :  * your code. (Extra memory is used for special buffers that are
     753                 :            :  * allocated when trace_puts() is used.)
     754                 :            :  *
     755                 :            :  * Returns: 0 if nothing was written, positive # if string was.
     756                 :            :  *  (1 when __trace_bputs is used, strlen(str) when __trace_puts is used)
     757                 :            :  */
     758                 :            : 
     759                 :            : #define trace_puts(str) ({                                              \
     760                 :            :         static const char *trace_printk_fmt __used                      \
     761                 :            :                 __attribute__((section("__trace_printk_fmt"))) =      \
     762                 :            :                 __builtin_constant_p(str) ? str : NULL;                 \
     763                 :            :                                                                         \
     764                 :            :         if (__builtin_constant_p(str))                                  \
     765                 :            :                 __trace_bputs(_THIS_IP_, trace_printk_fmt);             \
     766                 :            :         else                                                            \
     767                 :            :                 __trace_puts(_THIS_IP_, str, strlen(str));              \
     768                 :            : })
     769                 :            : extern int __trace_bputs(unsigned long ip, const char *str);
     770                 :            : extern int __trace_puts(unsigned long ip, const char *str, int size);
     771                 :            : 
     772                 :            : extern void trace_dump_stack(int skip);
     773                 :            : 
     774                 :            : /*
     775                 :            :  * The double __builtin_constant_p is because gcc will give us an error
     776                 :            :  * if we try to allocate the static variable to fmt if it is not a
     777                 :            :  * constant. Even with the outer if statement.
     778                 :            :  */
     779                 :            : #define ftrace_vprintk(fmt, vargs)                                      \
     780                 :            : do {                                                                    \
     781                 :            :         if (__builtin_constant_p(fmt)) {                                \
     782                 :            :                 static const char *trace_printk_fmt __used              \
     783                 :            :                   __attribute__((section("__trace_printk_fmt"))) =    \
     784                 :            :                         __builtin_constant_p(fmt) ? fmt : NULL;         \
     785                 :            :                                                                         \
     786                 :            :                 __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs);  \
     787                 :            :         } else                                                          \
     788                 :            :                 __ftrace_vprintk(_THIS_IP_, fmt, vargs);                \
     789                 :            : } while (0)
     790                 :            : 
     791                 :            : extern __printf(2, 0) int
     792                 :            : __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
     793                 :            : 
     794                 :            : extern __printf(2, 0) int
     795                 :            : __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
     796                 :            : 
     797                 :            : extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
     798                 :            : #else
     799                 :            : static inline void tracing_start(void) { }
     800                 :            : static inline void tracing_stop(void) { }
     801                 :            : static inline void trace_dump_stack(int skip) { }
     802                 :            : 
     803                 :            : static inline void tracing_on(void) { }
     804                 :            : static inline void tracing_off(void) { }
     805                 :            : static inline int tracing_is_on(void) { return 0; }
     806                 :            : static inline void tracing_snapshot(void) { }
     807                 :            : static inline void tracing_snapshot_alloc(void) { }
     808                 :            : 
     809                 :            : static inline __printf(1, 2)
     810                 :            : int trace_printk(const char *fmt, ...)
     811                 :            : {
     812                 :            :         return 0;
     813                 :            : }
     814                 :            : static __printf(1, 0) inline int
     815                 :            : ftrace_vprintk(const char *fmt, va_list ap)
     816                 :            : {
     817                 :            :         return 0;
     818                 :            : }
     819                 :            : static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
     820                 :            : #endif /* CONFIG_TRACING */
     821                 :            : 
     822                 :            : /*
     823                 :            :  * min()/max()/clamp() macros must accomplish three things:
     824                 :            :  *
     825                 :            :  * - avoid multiple evaluations of the arguments (so side-effects like
     826                 :            :  *   "x++" happen only once) when non-constant.
     827                 :            :  * - perform strict type-checking (to generate warnings instead of
     828                 :            :  *   nasty runtime surprises). See the "unnecessary" pointer comparison
     829                 :            :  *   in __typecheck().
     830                 :            :  * - retain result as a constant expressions when called with only
     831                 :            :  *   constant expressions (to avoid tripping VLA warnings in stack
     832                 :            :  *   allocation usage).
     833                 :            :  */
     834                 :            : #define __typecheck(x, y) \
     835                 :            :                 (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1)))
     836                 :            : 
     837                 :            : /*
     838                 :            :  * This returns a constant expression while determining if an argument is
     839                 :            :  * a constant expression, most importantly without evaluating the argument.
     840                 :            :  * Glory to Martin Uecker <Martin.Uecker@med.uni-goettingen.de>
     841                 :            :  */
     842                 :            : #define __is_constexpr(x) \
     843                 :            :         (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8)))
     844                 :            : 
     845                 :            : #define __no_side_effects(x, y) \
     846                 :            :                 (__is_constexpr(x) && __is_constexpr(y))
     847                 :            : 
     848                 :            : #define __safe_cmp(x, y) \
     849                 :            :                 (__typecheck(x, y) && __no_side_effects(x, y))
     850                 :            : 
     851                 :            : #define __cmp(x, y, op) ((x) op (y) ? (x) : (y))
     852                 :            : 
     853                 :            : #define __cmp_once(x, y, unique_x, unique_y, op) ({     \
     854                 :            :                 typeof(x) unique_x = (x);               \
     855                 :            :                 typeof(y) unique_y = (y);               \
     856                 :            :                 __cmp(unique_x, unique_y, op); })
     857                 :            : 
     858                 :            : #define __careful_cmp(x, y, op) \
     859                 :            :         __builtin_choose_expr(__safe_cmp(x, y), \
     860                 :            :                 __cmp(x, y, op), \
     861                 :            :                 __cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op))
     862                 :            : 
     863                 :            : /**
     864                 :            :  * min - return minimum of two values of the same or compatible types
     865                 :            :  * @x: first value
     866                 :            :  * @y: second value
     867                 :            :  */
     868                 :            : #define min(x, y)       __careful_cmp(x, y, <)
     869                 :            : 
     870                 :            : /**
     871                 :            :  * max - return maximum of two values of the same or compatible types
     872                 :            :  * @x: first value
     873                 :            :  * @y: second value
     874                 :            :  */
     875                 :            : #define max(x, y)       __careful_cmp(x, y, >)
     876                 :            : 
     877                 :            : /**
     878                 :            :  * min3 - return minimum of three values
     879                 :            :  * @x: first value
     880                 :            :  * @y: second value
     881                 :            :  * @z: third value
     882                 :            :  */
     883                 :            : #define min3(x, y, z) min((typeof(x))min(x, y), z)
     884                 :            : 
     885                 :            : /**
     886                 :            :  * max3 - return maximum of three values
     887                 :            :  * @x: first value
     888                 :            :  * @y: second value
     889                 :            :  * @z: third value
     890                 :            :  */
     891                 :            : #define max3(x, y, z) max((typeof(x))max(x, y), z)
     892                 :            : 
     893                 :            : /**
     894                 :            :  * min_not_zero - return the minimum that is _not_ zero, unless both are zero
     895                 :            :  * @x: value1
     896                 :            :  * @y: value2
     897                 :            :  */
     898                 :            : #define min_not_zero(x, y) ({                   \
     899                 :            :         typeof(x) __x = (x);                    \
     900                 :            :         typeof(y) __y = (y);                    \
     901                 :            :         __x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })
     902                 :            : 
     903                 :            : /**
     904                 :            :  * clamp - return a value clamped to a given range with strict typechecking
     905                 :            :  * @val: current value
     906                 :            :  * @lo: lowest allowable value
     907                 :            :  * @hi: highest allowable value
     908                 :            :  *
     909                 :            :  * This macro does strict typechecking of @lo/@hi to make sure they are of the
     910                 :            :  * same type as @val.  See the unnecessary pointer comparisons.
     911                 :            :  */
     912                 :            : #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)
     913                 :            : 
     914                 :            : /*
     915                 :            :  * ..and if you can't take the strict
     916                 :            :  * types, you can specify one yourself.
     917                 :            :  *
     918                 :            :  * Or not use min/max/clamp at all, of course.
     919                 :            :  */
     920                 :            : 
     921                 :            : /**
     922                 :            :  * min_t - return minimum of two values, using the specified type
     923                 :            :  * @type: data type to use
     924                 :            :  * @x: first value
     925                 :            :  * @y: second value
     926                 :            :  */
     927                 :            : #define min_t(type, x, y)       __careful_cmp((type)(x), (type)(y), <)
     928                 :            : 
     929                 :            : /**
     930                 :            :  * max_t - return maximum of two values, using the specified type
     931                 :            :  * @type: data type to use
     932                 :            :  * @x: first value
     933                 :            :  * @y: second value
     934                 :            :  */
     935                 :            : #define max_t(type, x, y)       __careful_cmp((type)(x), (type)(y), >)
     936                 :            : 
     937                 :            : /**
     938                 :            :  * clamp_t - return a value clamped to a given range using a given type
     939                 :            :  * @type: the type of variable to use
     940                 :            :  * @val: current value
     941                 :            :  * @lo: minimum allowable value
     942                 :            :  * @hi: maximum allowable value
     943                 :            :  *
     944                 :            :  * This macro does no typechecking and uses temporary variables of type
     945                 :            :  * @type to make all the comparisons.
     946                 :            :  */
     947                 :            : #define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi)
     948                 :            : 
     949                 :            : /**
     950                 :            :  * clamp_val - return a value clamped to a given range using val's type
     951                 :            :  * @val: current value
     952                 :            :  * @lo: minimum allowable value
     953                 :            :  * @hi: maximum allowable value
     954                 :            :  *
     955                 :            :  * This macro does no typechecking and uses temporary variables of whatever
     956                 :            :  * type the input argument @val is.  This is useful when @val is an unsigned
     957                 :            :  * type and @lo and @hi are literals that will otherwise be assigned a signed
     958                 :            :  * integer type.
     959                 :            :  */
     960                 :            : #define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi)
     961                 :            : 
     962                 :            : 
     963                 :            : /**
     964                 :            :  * swap - swap values of @a and @b
     965                 :            :  * @a: first value
     966                 :            :  * @b: second value
     967                 :            :  */
     968                 :            : #define swap(a, b) \
     969                 :            :         do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
     970                 :            : 
     971                 :            : /* This counts to 12. Any more, it will return 13th argument. */
     972                 :            : #define __COUNT_ARGS(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _n, X...) _n
     973                 :            : #define COUNT_ARGS(X...) __COUNT_ARGS(, ##X, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
     974                 :            : 
     975                 :            : #define __CONCAT(a, b) a ## b
     976                 :            : #define CONCATENATE(a, b) __CONCAT(a, b)
     977                 :            : 
     978                 :            : /**
     979                 :            :  * container_of - cast a member of a structure out to the containing structure
     980                 :            :  * @ptr:        the pointer to the member.
     981                 :            :  * @type:       the type of the container struct this is embedded in.
     982                 :            :  * @member:     the name of the member within the struct.
     983                 :            :  *
     984                 :            :  */
     985                 :            : #define container_of(ptr, type, member) ({                              \
     986                 :            :         void *__mptr = (void *)(ptr);                                   \
     987                 :            :         BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) &&        \
     988                 :            :                          !__same_type(*(ptr), void),                    \
     989                 :            :                          "pointer type mismatch in container_of()");  \
     990                 :            :         ((type *)(__mptr - offsetof(type, member))); })
     991                 :            : 
     992                 :            : /**
     993                 :            :  * container_of_safe - cast a member of a structure out to the containing structure
     994                 :            :  * @ptr:        the pointer to the member.
     995                 :            :  * @type:       the type of the container struct this is embedded in.
     996                 :            :  * @member:     the name of the member within the struct.
     997                 :            :  *
     998                 :            :  * If IS_ERR_OR_NULL(ptr), ptr is returned unchanged.
     999                 :            :  */
    1000                 :            : #define container_of_safe(ptr, type, member) ({                         \
    1001                 :            :         void *__mptr = (void *)(ptr);                                   \
    1002                 :            :         BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) &&        \
    1003                 :            :                          !__same_type(*(ptr), void),                    \
    1004                 :            :                          "pointer type mismatch in container_of()");  \
    1005                 :            :         IS_ERR_OR_NULL(__mptr) ? ERR_CAST(__mptr) :                     \
    1006                 :            :                 ((type *)(__mptr - offsetof(type, member))); })
    1007                 :            : 
    1008                 :            : /* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */
    1009                 :            : #ifdef CONFIG_FTRACE_MCOUNT_RECORD
    1010                 :            : # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
    1011                 :            : #endif
    1012                 :            : 
    1013                 :            : /* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */
    1014                 :            : #define VERIFY_OCTAL_PERMISSIONS(perms)                                         \
    1015                 :            :         (BUILD_BUG_ON_ZERO((perms) < 0) +                                    \
    1016                 :            :          BUILD_BUG_ON_ZERO((perms) > 0777) +                                 \
    1017                 :            :          /* USER_READABLE >= GROUP_READABLE >= OTHER_READABLE */          \
    1018                 :            :          BUILD_BUG_ON_ZERO((((perms) >> 6) & 4) < (((perms) >> 3) & 4)) +        \
    1019                 :            :          BUILD_BUG_ON_ZERO((((perms) >> 3) & 4) < ((perms) & 4)) +             \
    1020                 :            :          /* USER_WRITABLE >= GROUP_WRITABLE */                                       \
    1021                 :            :          BUILD_BUG_ON_ZERO((((perms) >> 6) & 2) < (((perms) >> 3) & 2)) +        \
    1022                 :            :          /* OTHER_WRITABLE?  Generally considered a bad idea. */                \
    1023                 :            :          BUILD_BUG_ON_ZERO((perms) & 2) +                                   \
    1024                 :            :          (perms))
    1025                 :            : #endif

Generated by: LCOV version 1.14