LCOV - code coverage report
Current view: top level - include/linux - kernel.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 4 18 22.2 %
Date: 2021-04-22 12:43:58 Functions: 0 0 -

          Line data    Source code
       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _LINUX_KERNEL_H
       3             : #define _LINUX_KERNEL_H
       4             : 
       5             : #include <stdarg.h>
       6             : #include <linux/limits.h>
       7             : #include <linux/linkage.h>
       8             : #include <linux/stddef.h>
       9             : #include <linux/types.h>
      10             : #include <linux/compiler.h>
      11             : #include <linux/bitops.h>
      12             : #include <linux/log2.h>
      13             : #include <linux/math.h>
      14             : #include <linux/minmax.h>
      15             : #include <linux/typecheck.h>
      16             : #include <linux/printk.h>
      17             : #include <linux/build_bug.h>
      18             : #include <linux/static_call_types.h>
      19             : #include <asm/byteorder.h>
      20             : 
      21             : #include <uapi/linux/kernel.h>
      22             : 
      23             : #define STACK_MAGIC     0xdeadbeef
      24             : 
      25             : /**
      26             :  * REPEAT_BYTE - repeat the value @x multiple times as an unsigned long value
      27             :  * @x: value to repeat
      28             :  *
      29             :  * NOTE: @x is not checked for > 0xff; larger values produce odd results.
      30             :  */
      31             : #define REPEAT_BYTE(x)  ((~0ul / 0xff) * (x))
      32             : 
      33             : /* @a is a power of 2 value */
      34             : #define ALIGN(x, a)             __ALIGN_KERNEL((x), (a))
      35             : #define ALIGN_DOWN(x, a)        __ALIGN_KERNEL((x) - ((a) - 1), (a))
      36             : #define __ALIGN_MASK(x, mask)   __ALIGN_KERNEL_MASK((x), (mask))
      37             : #define PTR_ALIGN(p, a)         ((typeof(p))ALIGN((unsigned long)(p), (a)))
      38             : #define PTR_ALIGN_DOWN(p, a)    ((typeof(p))ALIGN_DOWN((unsigned long)(p), (a)))
      39             : #define IS_ALIGNED(x, a)                (((x) & ((typeof(x))(a) - 1)) == 0)
      40             : 
      41             : /* generic data direction definitions */
      42             : #define READ                    0
      43             : #define WRITE                   1
      44             : 
      45             : /**
      46             :  * ARRAY_SIZE - get the number of elements in array @arr
      47             :  * @arr: array to be sized
      48             :  */
      49             : #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
      50             : 
      51             : #define u64_to_user_ptr(x) (            \
      52             : {                                       \
      53             :         typecheck(u64, (x));            \
      54             :         (void __user *)(uintptr_t)(x);  \
      55             : }                                       \
      56             : )
      57             : 
      58             : #define typeof_member(T, m)     typeof(((T*)0)->m)
      59             : 
      60             : #define _RET_IP_                (unsigned long)__builtin_return_address(0)
      61             : #define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
      62             : 
      63             : /**
      64             :  * upper_32_bits - return bits 32-63 of a number
      65             :  * @n: the number we're accessing
      66             :  *
      67             :  * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress
      68             :  * the "right shift count >= width of type" warning when that quantity is
      69             :  * 32-bits.
      70             :  */
      71             : #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
      72             : 
      73             : /**
      74             :  * lower_32_bits - return bits 0-31 of a number
      75             :  * @n: the number we're accessing
      76             :  */
      77             : #define lower_32_bits(n) ((u32)((n) & 0xffffffff))
      78             : 
      79             : struct completion;
      80             : struct pt_regs;
      81             : struct user;
      82             : 
      83             : #ifdef CONFIG_PREEMPT_VOLUNTARY
      84             : 
      85             : extern int __cond_resched(void);
      86             : # define might_resched() __cond_resched()
      87             : 
      88             : #elif defined(CONFIG_PREEMPT_DYNAMIC)
      89             : 
      90             : extern int __cond_resched(void);
      91             : 
      92             : DECLARE_STATIC_CALL(might_resched, __cond_resched);
      93             : 
      94             : static __always_inline void might_resched(void)
      95             : {
      96             :         static_call_mod(might_resched)();
      97             : }
      98             : 
      99             : #else
     100             : 
     101             : # define might_resched() do { } while (0)
     102             : 
     103             : #endif /* CONFIG_PREEMPT_* */
     104             : 
     105             : #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
     106             : extern void ___might_sleep(const char *file, int line, int preempt_offset);
     107             : extern void __might_sleep(const char *file, int line, int preempt_offset);
     108             : extern void __cant_sleep(const char *file, int line, int preempt_offset);
     109             : extern void __cant_migrate(const char *file, int line);
     110             : 
     111             : /**
     112             :  * might_sleep - annotation for functions that can sleep
     113             :  *
     114             :  * this macro will print a stack trace if it is executed in an atomic
     115             :  * context (spinlock, irq-handler, ...). Additional sections where blocking is
     116             :  * not allowed can be annotated with non_block_start() and non_block_end()
     117             :  * pairs.
     118             :  *
     119             :  * This is a useful debugging help to be able to catch problems early and not
     120             :  * be bitten later when the calling function happens to sleep when it is not
     121             :  * supposed to.
     122             :  */
     123             : # define might_sleep() \
     124             :         do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
     125             : /**
     126             :  * cant_sleep - annotation for functions that cannot sleep
     127             :  *
     128             :  * this macro will print a stack trace if it is executed with preemption enabled
     129             :  */
     130             : # define cant_sleep() \
     131             :         do { __cant_sleep(__FILE__, __LINE__, 0); } while (0)
     132             : # define sched_annotate_sleep() (current->task_state_change = 0)
     133             : 
     134             : /**
     135             :  * cant_migrate - annotation for functions that cannot migrate
     136             :  *
     137             :  * Will print a stack trace if executed in code which is migratable
     138             :  */
     139             : # define cant_migrate()                                                 \
     140             :         do {                                                            \
     141             :                 if (IS_ENABLED(CONFIG_SMP))                             \
     142             :                         __cant_migrate(__FILE__, __LINE__);             \
     143             :         } while (0)
     144             : 
     145             : /**
     146             :  * non_block_start - annotate the start of section where sleeping is prohibited
     147             :  *
     148             :  * This is on behalf of the oom reaper, specifically when it is calling the mmu
     149             :  * notifiers. The problem is that if the notifier were to block on, for example,
     150             :  * mutex_lock() and if the process which holds that mutex were to perform a
     151             :  * sleeping memory allocation, the oom reaper is now blocked on completion of
     152             :  * that memory allocation. Other blocking calls like wait_event() pose similar
     153             :  * issues.
     154             :  */
     155             : # define non_block_start() (current->non_block_count++)
     156             : /**
     157             :  * non_block_end - annotate the end of section where sleeping is prohibited
     158             :  *
     159             :  * Closes a section opened by non_block_start().
     160             :  */
     161             : # define non_block_end() WARN_ON(current->non_block_count-- == 0)
     162             : #else
     163             :   static inline void ___might_sleep(const char *file, int line,
     164             :                                    int preempt_offset) { }
     165             :   static inline void __might_sleep(const char *file, int line,
     166             :                                    int preempt_offset) { }
     167             : # define might_sleep() do { might_resched(); } while (0)
     168             : # define cant_sleep() do { } while (0)
     169             : # define cant_migrate()         do { } while (0)
     170             : # define sched_annotate_sleep() do { } while (0)
     171             : # define non_block_start() do { } while (0)
     172             : # define non_block_end() do { } while (0)
     173             : #endif
     174             : 
     175             : #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
     176             : 
     177             : #if defined(CONFIG_MMU) && \
     178             :         (defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP))
     179             : #define might_fault() __might_fault(__FILE__, __LINE__)
     180             : void __might_fault(const char *file, int line);
     181             : #else
     182             : static inline void might_fault(void) { }
     183             : #endif
     184             : 
     185             : extern struct atomic_notifier_head panic_notifier_list;
     186             : extern long (*panic_blink)(int state);
     187             : __printf(1, 2)
     188             : void panic(const char *fmt, ...) __noreturn __cold;
     189             : void nmi_panic(struct pt_regs *regs, const char *msg);
     190             : extern void oops_enter(void);
     191             : extern void oops_exit(void);
     192             : extern bool oops_may_print(void);
     193             : void do_exit(long error_code) __noreturn;
     194             : void complete_and_exit(struct completion *, long) __noreturn;
     195             : 
     196             : /* Internal, do not use. */
     197             : int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);
     198             : int __must_check _kstrtol(const char *s, unsigned int base, long *res);
     199             : 
     200             : int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res);
     201             : int __must_check kstrtoll(const char *s, unsigned int base, long long *res);
     202             : 
     203             : /**
     204             :  * kstrtoul - convert a string to an unsigned long
     205             :  * @s: The start of the string. The string must be null-terminated, and may also
     206             :  *  include a single newline before its terminating null. The first character
     207             :  *  may also be a plus sign, but not a minus sign.
     208             :  * @base: The number base to use. The maximum supported base is 16. If base is
     209             :  *  given as 0, then the base of the string is automatically detected with the
     210             :  *  conventional semantics - If it begins with 0x the number will be parsed as a
     211             :  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
     212             :  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
     213             :  * @res: Where to write the result of the conversion on success.
     214             :  *
     215             :  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
     216             :  * Preferred over simple_strtoul(). Return code must be checked.
     217             : */
     218           0 : static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
     219             : {
     220             :         /*
     221             :          * We want to shortcut function call, but
     222             :          * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0.
     223             :          */
     224           0 :         if (sizeof(unsigned long) == sizeof(unsigned long long) &&
     225             :             __alignof__(unsigned long) == __alignof__(unsigned long long))
     226           0 :                 return kstrtoull(s, base, (unsigned long long *)res);
     227             :         else
     228             :                 return _kstrtoul(s, base, res);
     229             : }
     230             : 
     231             : /**
     232             :  * kstrtol - convert a string to a long
     233             :  * @s: The start of the string. The string must be null-terminated, and may also
     234             :  *  include a single newline before its terminating null. The first character
     235             :  *  may also be a plus sign or a minus sign.
     236             :  * @base: The number base to use. The maximum supported base is 16. If base is
     237             :  *  given as 0, then the base of the string is automatically detected with the
     238             :  *  conventional semantics - If it begins with 0x the number will be parsed as a
     239             :  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
     240             :  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
     241             :  * @res: Where to write the result of the conversion on success.
     242             :  *
     243             :  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
     244             :  * Preferred over simple_strtol(). Return code must be checked.
     245             :  */
     246           0 : static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
     247             : {
     248             :         /*
     249             :          * We want to shortcut function call, but
     250             :          * __builtin_types_compatible_p(long, long long) = 0.
     251             :          */
     252           0 :         if (sizeof(long) == sizeof(long long) &&
     253             :             __alignof__(long) == __alignof__(long long))
     254           0 :                 return kstrtoll(s, base, (long long *)res);
     255             :         else
     256             :                 return _kstrtol(s, base, res);
     257             : }
     258             : 
     259             : int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res);
     260             : int __must_check kstrtoint(const char *s, unsigned int base, int *res);
     261             : 
     262             : static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res)
     263             : {
     264             :         return kstrtoull(s, base, res);
     265             : }
     266             : 
     267           0 : static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res)
     268             : {
     269           0 :         return kstrtoll(s, base, res);
     270             : }
     271             : 
     272           0 : static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res)
     273             : {
     274           0 :         return kstrtouint(s, base, res);
     275             : }
     276             : 
     277             : static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res)
     278             : {
     279             :         return kstrtoint(s, base, res);
     280             : }
     281             : 
     282             : int __must_check kstrtou16(const char *s, unsigned int base, u16 *res);
     283             : int __must_check kstrtos16(const char *s, unsigned int base, s16 *res);
     284             : int __must_check kstrtou8(const char *s, unsigned int base, u8 *res);
     285             : int __must_check kstrtos8(const char *s, unsigned int base, s8 *res);
     286             : int __must_check kstrtobool(const char *s, bool *res);
     287             : 
     288             : int __must_check kstrtoull_from_user(const char __user *s, size_t count, unsigned int base, unsigned long long *res);
     289             : int __must_check kstrtoll_from_user(const char __user *s, size_t count, unsigned int base, long long *res);
     290             : int __must_check kstrtoul_from_user(const char __user *s, size_t count, unsigned int base, unsigned long *res);
     291             : int __must_check kstrtol_from_user(const char __user *s, size_t count, unsigned int base, long *res);
     292             : int __must_check kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res);
     293             : int __must_check kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, int *res);
     294             : int __must_check kstrtou16_from_user(const char __user *s, size_t count, unsigned int base, u16 *res);
     295             : int __must_check kstrtos16_from_user(const char __user *s, size_t count, unsigned int base, s16 *res);
     296             : int __must_check kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, u8 *res);
     297             : int __must_check kstrtos8_from_user(const char __user *s, size_t count, unsigned int base, s8 *res);
     298             : int __must_check kstrtobool_from_user(const char __user *s, size_t count, bool *res);
     299             : 
     300             : static inline int __must_check kstrtou64_from_user(const char __user *s, size_t count, unsigned int base, u64 *res)
     301             : {
     302             :         return kstrtoull_from_user(s, count, base, res);
     303             : }
     304             : 
     305             : static inline int __must_check kstrtos64_from_user(const char __user *s, size_t count, unsigned int base, s64 *res)
     306             : {
     307             :         return kstrtoll_from_user(s, count, base, res);
     308             : }
     309             : 
     310             : static inline int __must_check kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, u32 *res)
     311             : {
     312             :         return kstrtouint_from_user(s, count, base, res);
     313             : }
     314             : 
     315             : static inline int __must_check kstrtos32_from_user(const char __user *s, size_t count, unsigned int base, s32 *res)
     316             : {
     317             :         return kstrtoint_from_user(s, count, base, res);
     318             : }
     319             : 
     320             : /*
     321             :  * Use kstrto<foo> instead.
     322             :  *
     323             :  * NOTE: simple_strto<foo> does not check for the range overflow and,
     324             :  *       depending on the input, may give interesting results.
     325             :  *
     326             :  * Use these functions if and only if you cannot use kstrto<foo>, because
     327             :  * the conversion ends on the first non-digit character, which may be far
     328             :  * beyond the supported range. It might be useful to parse the strings like
     329             :  * 10x50 or 12:21 without altering original string or temporary buffer in use.
     330             :  * Keep in mind above caveat.
     331             :  */
     332             : 
     333             : extern unsigned long simple_strtoul(const char *,char **,unsigned int);
     334             : extern long simple_strtol(const char *,char **,unsigned int);
     335             : extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
     336             : extern long long simple_strtoll(const char *,char **,unsigned int);
     337             : 
     338             : extern int num_to_str(char *buf, int size,
     339             :                       unsigned long long num, unsigned int width);
     340             : 
     341             : /* lib/printf utilities */
     342             : 
     343             : extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
     344             : extern __printf(2, 0) int vsprintf(char *buf, const char *, va_list);
     345             : extern __printf(3, 4)
     346             : int snprintf(char *buf, size_t size, const char *fmt, ...);
     347             : extern __printf(3, 0)
     348             : int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
     349             : extern __printf(3, 4)
     350             : int scnprintf(char *buf, size_t size, const char *fmt, ...);
     351             : extern __printf(3, 0)
     352             : int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
     353             : extern __printf(2, 3) __malloc
     354             : char *kasprintf(gfp_t gfp, const char *fmt, ...);
     355             : extern __printf(2, 0) __malloc
     356             : char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
     357             : extern __printf(2, 0)
     358             : const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);
     359             : 
     360             : extern __scanf(2, 3)
     361             : int sscanf(const char *, const char *, ...);
     362             : extern __scanf(2, 0)
     363             : int vsscanf(const char *, const char *, va_list);
     364             : 
     365             : extern int get_option(char **str, int *pint);
     366             : extern char *get_options(const char *str, int nints, int *ints);
     367             : extern unsigned long long memparse(const char *ptr, char **retptr);
     368             : extern bool parse_option_str(const char *str, const char *option);
     369             : extern char *next_arg(char *args, char **param, char **val);
     370             : 
     371             : extern int core_kernel_text(unsigned long addr);
     372             : extern int init_kernel_text(unsigned long addr);
     373             : extern int core_kernel_data(unsigned long addr);
     374             : extern int __kernel_text_address(unsigned long addr);
     375             : extern int kernel_text_address(unsigned long addr);
     376             : extern int func_ptr_is_kernel_text(void *ptr);
     377             : 
     378             : #ifdef CONFIG_SMP
     379             : extern unsigned int sysctl_oops_all_cpu_backtrace;
     380             : #else
     381             : #define sysctl_oops_all_cpu_backtrace 0
     382             : #endif /* CONFIG_SMP */
     383             : 
     384             : extern void bust_spinlocks(int yes);
     385             : extern int panic_timeout;
     386             : extern unsigned long panic_print;
     387             : extern int panic_on_oops;
     388             : extern int panic_on_unrecovered_nmi;
     389             : extern int panic_on_io_nmi;
     390             : extern int panic_on_warn;
     391             : extern unsigned long panic_on_taint;
     392             : extern bool panic_on_taint_nousertaint;
     393             : extern int sysctl_panic_on_rcu_stall;
     394             : extern int sysctl_max_rcu_stall_to_panic;
     395             : extern int sysctl_panic_on_stackoverflow;
     396             : 
     397             : extern bool crash_kexec_post_notifiers;
     398             : 
     399             : /*
     400             :  * panic_cpu is used for synchronizing panic() and crash_kexec() execution. It
     401             :  * holds a CPU number which is executing panic() currently. A value of
     402             :  * PANIC_CPU_INVALID means no CPU has entered panic() or crash_kexec().
     403             :  */
     404             : extern atomic_t panic_cpu;
     405             : #define PANIC_CPU_INVALID       -1
     406             : 
     407             : /*
     408             :  * Only to be used by arch init code. If the user over-wrote the default
     409             :  * CONFIG_PANIC_TIMEOUT, honor it.
     410             :  */
     411             : static inline void set_arch_panic_timeout(int timeout, int arch_default_timeout)
     412             : {
     413             :         if (panic_timeout == arch_default_timeout)
     414             :                 panic_timeout = timeout;
     415             : }
     416             : extern const char *print_tainted(void);
     417             : enum lockdep_ok {
     418             :         LOCKDEP_STILL_OK,
     419             :         LOCKDEP_NOW_UNRELIABLE
     420             : };
     421             : extern void add_taint(unsigned flag, enum lockdep_ok);
     422             : extern int test_taint(unsigned flag);
     423             : extern unsigned long get_taint(void);
     424             : extern int root_mountflags;
     425             : 
     426             : extern bool early_boot_irqs_disabled;
     427             : 
     428             : /*
     429             :  * Values used for system_state. Ordering of the states must not be changed
     430             :  * as code checks for <, <=, >, >= STATE.
     431             :  */
     432             : extern enum system_states {
     433             :         SYSTEM_BOOTING,
     434             :         SYSTEM_SCHEDULING,
     435             :         SYSTEM_RUNNING,
     436             :         SYSTEM_HALT,
     437             :         SYSTEM_POWER_OFF,
     438             :         SYSTEM_RESTART,
     439             :         SYSTEM_SUSPEND,
     440             : } system_state;
     441             : 
     442             : /* This cannot be an enum because some may be used in assembly source. */
     443             : #define TAINT_PROPRIETARY_MODULE        0
     444             : #define TAINT_FORCED_MODULE             1
     445             : #define TAINT_CPU_OUT_OF_SPEC           2
     446             : #define TAINT_FORCED_RMMOD              3
     447             : #define TAINT_MACHINE_CHECK             4
     448             : #define TAINT_BAD_PAGE                  5
     449             : #define TAINT_USER                      6
     450             : #define TAINT_DIE                       7
     451             : #define TAINT_OVERRIDDEN_ACPI_TABLE     8
     452             : #define TAINT_WARN                      9
     453             : #define TAINT_CRAP                      10
     454             : #define TAINT_FIRMWARE_WORKAROUND       11
     455             : #define TAINT_OOT_MODULE                12
     456             : #define TAINT_UNSIGNED_MODULE           13
     457             : #define TAINT_SOFTLOCKUP                14
     458             : #define TAINT_LIVEPATCH                 15
     459             : #define TAINT_AUX                       16
     460             : #define TAINT_RANDSTRUCT                17
     461             : #define TAINT_FLAGS_COUNT               18
     462             : #define TAINT_FLAGS_MAX                 ((1UL << TAINT_FLAGS_COUNT) - 1)
     463             : 
     464             : struct taint_flag {
     465             :         char c_true;    /* character printed when tainted */
     466             :         char c_false;   /* character printed when not tainted */
     467             :         bool module;    /* also show as a per-module taint flag */
     468             : };
     469             : 
     470             : extern const struct taint_flag taint_flags[TAINT_FLAGS_COUNT];
     471             : 
     472             : extern const char hex_asc[];
     473             : #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
     474             : #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
     475             : 
     476         256 : static inline char *hex_byte_pack(char *buf, u8 byte)
     477             : {
     478         256 :         *buf++ = hex_asc_hi(byte);
     479         256 :         *buf++ = hex_asc_lo(byte);
     480         256 :         return buf;
     481             : }
     482             : 
     483             : extern const char hex_asc_upper[];
     484             : #define hex_asc_upper_lo(x)     hex_asc_upper[((x) & 0x0f)]
     485             : #define hex_asc_upper_hi(x)     hex_asc_upper[((x) & 0xf0) >> 4]
     486             : 
     487           0 : static inline char *hex_byte_pack_upper(char *buf, u8 byte)
     488             : {
     489           0 :         *buf++ = hex_asc_upper_hi(byte);
     490           0 :         *buf++ = hex_asc_upper_lo(byte);
     491           0 :         return buf;
     492             : }
     493             : 
     494             : extern int hex_to_bin(char ch);
     495             : extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
     496             : extern char *bin2hex(char *dst, const void *src, size_t count);
     497             : 
     498             : bool mac_pton(const char *s, u8 *mac);
     499             : 
     500             : /*
     501             :  * General tracing related utility functions - trace_printk(),
     502             :  * tracing_on/tracing_off and tracing_start()/tracing_stop
     503             :  *
     504             :  * Use tracing_on/tracing_off when you want to quickly turn on or off
     505             :  * tracing. It simply enables or disables the recording of the trace events.
     506             :  * This also corresponds to the user space /sys/kernel/debug/tracing/tracing_on
     507             :  * file, which gives a means for the kernel and userspace to interact.
     508             :  * Place a tracing_off() in the kernel where you want tracing to end.
     509             :  * From user space, examine the trace, and then echo 1 > tracing_on
     510             :  * to continue tracing.
     511             :  *
     512             :  * tracing_stop/tracing_start has slightly more overhead. It is used
     513             :  * by things like suspend to ram where disabling the recording of the
     514             :  * trace is not enough, but tracing must actually stop because things
     515             :  * like calling smp_processor_id() may crash the system.
     516             :  *
     517             :  * Most likely, you want to use tracing_on/tracing_off.
     518             :  */
     519             : 
     520             : enum ftrace_dump_mode {
     521             :         DUMP_NONE,
     522             :         DUMP_ALL,
     523             :         DUMP_ORIG,
     524             : };
     525             : 
     526             : #ifdef CONFIG_TRACING
     527             : void tracing_on(void);
     528             : void tracing_off(void);
     529             : int tracing_is_on(void);
     530             : void tracing_snapshot(void);
     531             : void tracing_snapshot_alloc(void);
     532             : 
     533             : extern void tracing_start(void);
     534             : extern void tracing_stop(void);
     535             : 
     536             : static inline __printf(1, 2)
     537             : void ____trace_printk_check_format(const char *fmt, ...)
     538             : {
     539             : }
     540             : #define __trace_printk_check_format(fmt, args...)                       \
     541             : do {                                                                    \
     542             :         if (0)                                                          \
     543             :                 ____trace_printk_check_format(fmt, ##args);             \
     544             : } while (0)
     545             : 
     546             : /**
     547             :  * trace_printk - printf formatting in the ftrace buffer
     548             :  * @fmt: the printf format for printing
     549             :  *
     550             :  * Note: __trace_printk is an internal function for trace_printk() and
     551             :  *       the @ip is passed in via the trace_printk() macro.
     552             :  *
     553             :  * This function allows a kernel developer to debug fast path sections
     554             :  * that printk is not appropriate for. By scattering in various
     555             :  * printk like tracing in the code, a developer can quickly see
     556             :  * where problems are occurring.
     557             :  *
     558             :  * This is intended as a debugging tool for the developer only.
     559             :  * Please refrain from leaving trace_printks scattered around in
     560             :  * your code. (Extra memory is used for special buffers that are
     561             :  * allocated when trace_printk() is used.)
     562             :  *
     563             :  * A little optimization trick is done here. If there's only one
     564             :  * argument, there's no need to scan the string for printf formats.
     565             :  * The trace_puts() will suffice. But how can we take advantage of
     566             :  * using trace_puts() when trace_printk() has only one argument?
     567             :  * By stringifying the args and checking the size we can tell
     568             :  * whether or not there are args. __stringify((__VA_ARGS__)) will
     569             :  * turn into "()\0" with a size of 3 when there are no args, anything
     570             :  * else will be bigger. All we need to do is define a string to this,
     571             :  * and then take its size and compare to 3. If it's bigger, use
     572             :  * do_trace_printk() otherwise, optimize it to trace_puts(). Then just
     573             :  * let gcc optimize the rest.
     574             :  */
     575             : 
     576             : #define trace_printk(fmt, ...)                          \
     577             : do {                                                    \
     578             :         char _______STR[] = __stringify((__VA_ARGS__)); \
     579             :         if (sizeof(_______STR) > 3)                  \
     580             :                 do_trace_printk(fmt, ##__VA_ARGS__);    \
     581             :         else                                            \
     582             :                 trace_puts(fmt);                        \
     583             : } while (0)
     584             : 
     585             : #define do_trace_printk(fmt, args...)                                   \
     586             : do {                                                                    \
     587             :         static const char *trace_printk_fmt __used                      \
     588             :                 __section("__trace_printk_fmt") =                     \
     589             :                 __builtin_constant_p(fmt) ? fmt : NULL;                 \
     590             :                                                                         \
     591             :         __trace_printk_check_format(fmt, ##args);                       \
     592             :                                                                         \
     593             :         if (__builtin_constant_p(fmt))                                  \
     594             :                 __trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args);   \
     595             :         else                                                            \
     596             :                 __trace_printk(_THIS_IP_, fmt, ##args);                 \
     597             : } while (0)
     598             : 
     599             : extern __printf(2, 3)
     600             : int __trace_bprintk(unsigned long ip, const char *fmt, ...);
     601             : 
     602             : extern __printf(2, 3)
     603             : int __trace_printk(unsigned long ip, const char *fmt, ...);
     604             : 
     605             : /**
     606             :  * trace_puts - write a string into the ftrace buffer
     607             :  * @str: the string to record
     608             :  *
     609             :  * Note: __trace_bputs is an internal function for trace_puts and
     610             :  *       the @ip is passed in via the trace_puts macro.
     611             :  *
     612             :  * This is similar to trace_printk() but is made for those really fast
     613             :  * paths that a developer wants the least amount of "Heisenbug" effects,
     614             :  * where the processing of the print format is still too much.
     615             :  *
     616             :  * This function allows a kernel developer to debug fast path sections
     617             :  * that printk is not appropriate for. By scattering in various
     618             :  * printk like tracing in the code, a developer can quickly see
     619             :  * where problems are occurring.
     620             :  *
     621             :  * This is intended as a debugging tool for the developer only.
     622             :  * Please refrain from leaving trace_puts scattered around in
     623             :  * your code. (Extra memory is used for special buffers that are
     624             :  * allocated when trace_puts() is used.)
     625             :  *
     626             :  * Returns: 0 if nothing was written, positive # if string was.
     627             :  *  (1 when __trace_bputs is used, strlen(str) when __trace_puts is used)
     628             :  */
     629             : 
     630             : #define trace_puts(str) ({                                              \
     631             :         static const char *trace_printk_fmt __used                      \
     632             :                 __section("__trace_printk_fmt") =                     \
     633             :                 __builtin_constant_p(str) ? str : NULL;                 \
     634             :                                                                         \
     635             :         if (__builtin_constant_p(str))                                  \
     636             :                 __trace_bputs(_THIS_IP_, trace_printk_fmt);             \
     637             :         else                                                            \
     638             :                 __trace_puts(_THIS_IP_, str, strlen(str));              \
     639             : })
     640             : extern int __trace_bputs(unsigned long ip, const char *str);
     641             : extern int __trace_puts(unsigned long ip, const char *str, int size);
     642             : 
     643             : extern void trace_dump_stack(int skip);
     644             : 
     645             : /*
     646             :  * The double __builtin_constant_p is because gcc will give us an error
     647             :  * if we try to allocate the static variable to fmt if it is not a
     648             :  * constant. Even with the outer if statement.
     649             :  */
     650             : #define ftrace_vprintk(fmt, vargs)                                      \
     651             : do {                                                                    \
     652             :         if (__builtin_constant_p(fmt)) {                                \
     653             :                 static const char *trace_printk_fmt __used              \
     654             :                   __section("__trace_printk_fmt") =                   \
     655             :                         __builtin_constant_p(fmt) ? fmt : NULL;         \
     656             :                                                                         \
     657             :                 __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs);  \
     658             :         } else                                                          \
     659             :                 __ftrace_vprintk(_THIS_IP_, fmt, vargs);                \
     660             : } while (0)
     661             : 
     662             : extern __printf(2, 0) int
     663             : __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
     664             : 
     665             : extern __printf(2, 0) int
     666             : __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
     667             : 
     668             : extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
     669             : #else
     670             : static inline void tracing_start(void) { }
     671             : static inline void tracing_stop(void) { }
     672             : static inline void trace_dump_stack(int skip) { }
     673             : 
     674             : static inline void tracing_on(void) { }
     675             : static inline void tracing_off(void) { }
     676             : static inline int tracing_is_on(void) { return 0; }
     677             : static inline void tracing_snapshot(void) { }
     678             : static inline void tracing_snapshot_alloc(void) { }
     679             : 
     680             : static inline __printf(1, 2)
     681             : int trace_printk(const char *fmt, ...)
     682             : {
     683             :         return 0;
     684             : }
     685             : static __printf(1, 0) inline int
     686             : ftrace_vprintk(const char *fmt, va_list ap)
     687             : {
     688             :         return 0;
     689             : }
     690             : static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
     691             : #endif /* CONFIG_TRACING */
     692             : 
     693             : /* This counts to 12. Any more, it will return 13th argument. */
     694             : #define __COUNT_ARGS(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _n, X...) _n
     695             : #define COUNT_ARGS(X...) __COUNT_ARGS(, ##X, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
     696             : 
     697             : #define __CONCAT(a, b) a ## b
     698             : #define CONCATENATE(a, b) __CONCAT(a, b)
     699             : 
     700             : /**
     701             :  * container_of - cast a member of a structure out to the containing structure
     702             :  * @ptr:        the pointer to the member.
     703             :  * @type:       the type of the container struct this is embedded in.
     704             :  * @member:     the name of the member within the struct.
     705             :  *
     706             :  */
     707             : #define container_of(ptr, type, member) ({                              \
     708             :         void *__mptr = (void *)(ptr);                                   \
     709             :         BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) &&        \
     710             :                          !__same_type(*(ptr), void),                    \
     711             :                          "pointer type mismatch in container_of()");  \
     712             :         ((type *)(__mptr - offsetof(type, member))); })
     713             : 
     714             : /**
     715             :  * container_of_safe - cast a member of a structure out to the containing structure
     716             :  * @ptr:        the pointer to the member.
     717             :  * @type:       the type of the container struct this is embedded in.
     718             :  * @member:     the name of the member within the struct.
     719             :  *
     720             :  * If IS_ERR_OR_NULL(ptr), ptr is returned unchanged.
     721             :  */
     722             : #define container_of_safe(ptr, type, member) ({                         \
     723             :         void *__mptr = (void *)(ptr);                                   \
     724             :         BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) &&        \
     725             :                          !__same_type(*(ptr), void),                    \
     726             :                          "pointer type mismatch in container_of()");  \
     727             :         IS_ERR_OR_NULL(__mptr) ? ERR_CAST(__mptr) :                     \
     728             :                 ((type *)(__mptr - offsetof(type, member))); })
     729             : 
     730             : /* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */
     731             : #ifdef CONFIG_FTRACE_MCOUNT_RECORD
     732             : # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
     733             : #endif
     734             : 
     735             : /* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */
     736             : #define VERIFY_OCTAL_PERMISSIONS(perms)                                         \
     737             :         (BUILD_BUG_ON_ZERO((perms) < 0) +                                    \
     738             :          BUILD_BUG_ON_ZERO((perms) > 0777) +                                 \
     739             :          /* USER_READABLE >= GROUP_READABLE >= OTHER_READABLE */          \
     740             :          BUILD_BUG_ON_ZERO((((perms) >> 6) & 4) < (((perms) >> 3) & 4)) +        \
     741             :          BUILD_BUG_ON_ZERO((((perms) >> 3) & 4) < ((perms) & 4)) +             \
     742             :          /* USER_WRITABLE >= GROUP_WRITABLE */                                       \
     743             :          BUILD_BUG_ON_ZERO((((perms) >> 6) & 2) < (((perms) >> 3) & 2)) +        \
     744             :          /* OTHER_WRITABLE?  Generally considered a bad idea. */                \
     745             :          BUILD_BUG_ON_ZERO((perms) & 2) +                                   \
     746             :          (perms))
     747             : #endif

Generated by: LCOV version 1.14