root/include/linux/kernel.h

INCLUDED FROM

DEFINITIONS

1. ___might_sleep
2. __might_sleep
3. reciprocal_scale
4. might_fault
5. __printf
6. kstrtoul
7. kstrtol
8. kstrtou64
9. kstrtos64
10. kstrtou32
11. kstrtos32
12. kstrtou64_from_user
13. kstrtos64_from_user
14. kstrtou32_from_user
15. kstrtos32_from_user
16. __printf
17. set_arch_panic_timeout
18. hex_byte_pack
19. hex_byte_pack_upper
20. __printf
21. __printf
22. tracing_stop
23. trace_dump_stack
24. tracing_on
25. tracing_off
26. tracing_is_on
27. tracing_snapshot
28. tracing_snapshot_alloc
29. __printf
30. __printf
31. ftrace_dump

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