LCOV - code coverage report
Current view: top level - include/linux - kernel.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _LINUX_KERNEL_H
       2             : #define _LINUX_KERNEL_H
       3             : 
       4             : /*
       5             :  * 'kernel.h' contains some often-used function prototypes etc
       6             :  */
       7             : 
       8             : #ifdef __KERNEL__
       9             : 
      10             : #include <stdarg.h>
      11             : #include <linux/linkage.h>
      12             : #include <linux/stddef.h>
      13             : #include <linux/types.h>
      14             : #include <linux/compiler.h>
      15             : #include <linux/bitops.h>
      16             : #include <linux/log2.h>
      17             : #include <linux/typecheck.h>
      18             : #include <linux/dynamic_debug.h>
      19             : #include <asm/byteorder.h>
      20             : #include <asm/bug.h>
      21             : 
      22             : extern const char linux_banner[];
      23             : extern const char linux_proc_banner[];
      24             : 
      25             : #define USHORT_MAX      ((u16)(~0U))
      26             : #define SHORT_MAX       ((s16)(USHORT_MAX>>1))
      27             : #define SHORT_MIN       (-SHORT_MAX - 1)
      28             : #define INT_MAX         ((int)(~0U>>1))
      29             : #define INT_MIN         (-INT_MAX - 1)
      30             : #define UINT_MAX        (~0U)
      31             : #define LONG_MAX        ((long)(~0UL>>1))
      32             : #define LONG_MIN        (-LONG_MAX - 1)
      33             : #define ULONG_MAX       (~0UL)
      34             : #define LLONG_MAX       ((long long)(~0ULL>>1))
      35             : #define LLONG_MIN       (-LLONG_MAX - 1)
      36             : #define ULLONG_MAX      (~0ULL)
      37             : 
      38             : #define STACK_MAGIC     0xdeadbeef
      39             : 
      40             : #define ALIGN(x,a)              __ALIGN_MASK(x,(typeof(x))(a)-1)
      41             : #define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
      42             : #define PTR_ALIGN(p, a)         ((typeof(p))ALIGN((unsigned long)(p), (a)))
      43             : #define IS_ALIGNED(x, a)                (((x) & ((typeof(x))(a) - 1)) == 0)
      44             : 
      45             : #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
      46             : 
      47             : #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
      48             : #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
      49             : #define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
      50             : #define DIV_ROUND_CLOSEST(x, divisor)(                  \
      51             : {                                                       \
      52             :         typeof(divisor) __divisor = divisor;            \
      53             :         (((x) + ((__divisor) / 2)) / (__divisor));      \
      54             : }                                                       \
      55             : )
      56             : 
      57             : #define _RET_IP_                (unsigned long)__builtin_return_address(0)
      58             : #define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
      59             : 
      60             : #ifdef CONFIG_LBDAF
      61             : # include <asm/div64.h>
      62             : # define sector_div(a, b) do_div(a, b)
      63             : #else
      64             : # define sector_div(n, b)( \
      65             : { \
      66             :         int _res; \
      67             :         _res = (n) % (b); \
      68             :         (n) /= (b); \
      69             :         _res; \
      70             : } \
      71             : )
      72             : #endif
      73             : 
      74             : /**
      75             :  * upper_32_bits - return bits 32-63 of a number
      76             :  * @n: the number we're accessing
      77             :  *
      78             :  * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress
      79             :  * the "right shift count >= width of type" warning when that quantity is
      80             :  * 32-bits.
      81             :  */
      82             : #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
      83             : 
      84             : /**
      85             :  * lower_32_bits - return bits 0-31 of a number
      86             :  * @n: the number we're accessing
      87             :  */
      88             : #define lower_32_bits(n) ((u32)(n))
      89             : 
      90             : #define KERN_EMERG      "<0>"   /* system is unusable                   */
      91             : #define KERN_ALERT      "<1>"   /* action must be taken immediately     */
      92             : #define KERN_CRIT       "<2>"   /* critical conditions                  */
      93             : #define KERN_ERR        "<3>"   /* error conditions                     */
      94             : #define KERN_WARNING    "<4>"   /* warning conditions                   */
      95             : #define KERN_NOTICE     "<5>"   /* normal but significant condition     */
      96             : #define KERN_INFO       "<6>"   /* informational                        */
      97             : #define KERN_DEBUG      "<7>"   /* debug-level messages                 */
      98             : 
      99             : /* Use the default kernel loglevel */
     100             : #define KERN_DEFAULT    "<d>"
     101             : /*
     102             :  * Annotation for a "continued" line of log printout (only done after a
     103             :  * line that had no enclosing \n). Only to be used by core/arch code
     104             :  * during early bootup (a continued line is not SMP-safe otherwise).
     105             :  */
     106             : #define KERN_CONT       "<c>"
     107             : 
     108             : extern int console_printk[];
     109           1 : 
     110             : #define console_loglevel (console_printk[0])
     111             : #define default_message_loglevel (console_printk[1])
     112             : #define minimum_console_loglevel (console_printk[2])
     113             : #define default_console_loglevel (console_printk[3])
     114             : 
     115             : struct completion;
     116             : struct pt_regs;
     117             : struct user;
     118             : 
     119             : #ifdef CONFIG_PREEMPT_VOLUNTARY
     120             : extern int _cond_resched(void);
     121             : # define might_resched() _cond_resched()
     122             : #else
     123             : # define might_resched() do { } while (0)
     124             : #endif
     125             : 
     126             : #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
     127             :   void __might_sleep(char *file, int line, int preempt_offset);
     128             : /**
     129             :  * might_sleep - annotation for functions that can sleep
     130             :  *
     131             :  * this macro will print a stack trace if it is executed in an atomic
     132             :  * context (spinlock, irq-handler, ...).
     133             :  *
     134             :  * This is a useful debugging help to be able to catch problems early and not
     135             :  * be bitten later when the calling function happens to sleep when it is not
     136             :  * supposed to.
     137             :  */
     138             : # define might_sleep() \
     139             :         do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
     140             : #else
     141             :   static inline void __might_sleep(char *file, int line, int preempt_offset) { }
     142             : # define might_sleep() do { might_resched(); } while (0)
     143             : #endif
     144             : 
     145             : #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
     146             : 
     147             : #define abs(x) ({                               \
     148             :                 long __x = (x);                 \
     149             :                 (__x < 0) ? -__x : __x;              \
     150             :         })
     151             : 
     152             : #ifdef CONFIG_PROVE_LOCKING
     153             : void might_fault(void);
     154             : #else
     155             : static inline void might_fault(void)
     156             : {
     157             :         might_sleep();
     158             : }
     159             : #endif
     160             : 
     161             : extern struct atomic_notifier_head panic_notifier_list;
     162             : extern long (*panic_blink)(long time);
     163             : NORET_TYPE void panic(const char * fmt, ...)
     164             :         __attribute__ ((NORET_AND format (printf, 1, 2))) __cold;
     165             : extern void oops_enter(void);
     166             : extern void oops_exit(void);
     167             : extern int oops_may_print(void);
     168             : NORET_TYPE void do_exit(long error_code)
     169             :         ATTRIB_NORET;
     170             : NORET_TYPE void complete_and_exit(struct completion *, long)
     171             :         ATTRIB_NORET;
     172             : extern unsigned long simple_strtoul(const char *,char **,unsigned int);
     173             : extern long simple_strtol(const char *,char **,unsigned int);
     174             : extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
     175             : extern long long simple_strtoll(const char *,char **,unsigned int);
     176             : extern int strict_strtoul(const char *, unsigned int, unsigned long *);
     177             : extern int strict_strtol(const char *, unsigned int, long *);
     178             : extern int strict_strtoull(const char *, unsigned int, unsigned long long *);
     179             : extern int strict_strtoll(const char *, unsigned int, long long *);
     180             : extern int sprintf(char * buf, const char * fmt, ...)
     181             :         __attribute__ ((format (printf, 2, 3)));
     182             : extern int vsprintf(char *buf, const char *, va_list)
     183             :         __attribute__ ((format (printf, 2, 0)));
     184             : extern int snprintf(char * buf, size_t size, const char * fmt, ...)
     185             :         __attribute__ ((format (printf, 3, 4)));
     186             : extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
     187             :         __attribute__ ((format (printf, 3, 0)));
     188             : extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
     189             :         __attribute__ ((format (printf, 3, 4)));
     190             : extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
     191             :         __attribute__ ((format (printf, 3, 0)));
     192             : extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
     193             :         __attribute__ ((format (printf, 2, 3)));
     194             : extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
     195             : 
     196             : extern int sscanf(const char *, const char *, ...)
     197             :         __attribute__ ((format (scanf, 2, 3)));
     198             : extern int vsscanf(const char *, const char *, va_list)
     199             :         __attribute__ ((format (scanf, 2, 0)));
     200             : 
     201             : extern int get_option(char **str, int *pint);
     202             : extern char *get_options(const char *str, int nints, int *ints);
     203             : extern unsigned long long memparse(const char *ptr, char **retptr);
     204             : 
     205             : extern int core_kernel_text(unsigned long addr);
     206             : extern int __kernel_text_address(unsigned long addr);
     207             : extern int kernel_text_address(unsigned long addr);
     208             : extern int func_ptr_is_kernel_text(void *ptr);
     209           1 : 
     210             : struct pid;
     211             : extern struct pid *session_of_pgrp(struct pid *pgrp);
     212             : 
     213             : /*
     214             :  * FW_BUG
     215             :  * Add this to a message where you are sure the firmware is buggy or behaves
     216             :  * really stupid or out of spec. Be aware that the responsible BIOS developer
     217             :  * should be able to fix this issue or at least get a concrete idea of the
     218             :  * problem by reading your message without the need of looking at the kernel
     219             :  * code.
     220             :  * 
     221             :  * Use it for definite and high priority BIOS bugs.
     222             :  *
     223             :  * FW_WARN
     224             :  * Use it for not that clear (e.g. could the kernel messed up things already?)
     225             :  * and medium priority BIOS bugs.
     226             :  *
     227             :  * FW_INFO
     228             :  * Use this one if you want to tell the user or vendor about something
     229             :  * suspicious, but generally harmless related to the firmware.
     230             :  *
     231             :  * Use it for information or very low priority BIOS bugs.
     232             :  */
     233             : #define FW_BUG          "[Firmware Bug]: "
     234             : #define FW_WARN         "[Firmware Warn]: "
     235             : #define FW_INFO         "[Firmware Info]: "
     236             : 
     237             : #ifdef CONFIG_PRINTK
     238             : asmlinkage int vprintk(const char *fmt, va_list args)
     239             :         __attribute__ ((format (printf, 1, 0)));
     240             : asmlinkage int printk(const char * fmt, ...)
     241             :         __attribute__ ((format (printf, 1, 2))) __cold;
     242             : 
     243             : extern int __printk_ratelimit(const char *func);
     244             : #define printk_ratelimit() __printk_ratelimit(__func__)
     245             : extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
     246             :                                    unsigned int interval_msec);
     247             : 
     248             : extern int printk_delay_msec;
     249             : 
     250             : /*
     251             :  * Print a one-time message (analogous to WARN_ONCE() et al):
     252             :  */
     253             : #define printk_once(x...) ({                    \
     254             :         static bool __print_once;               \
     255             :                                                 \
     256             :         if (!__print_once) {                    \
     257             :                 __print_once = true;            \
     258             :                 printk(x);                      \
     259             :         }                                       \
     260             : })
     261             : 
     262             : void log_buf_kexec_setup(void);
     263             : #else
     264             : static inline int vprintk(const char *s, va_list args)
     265             :         __attribute__ ((format (printf, 1, 0)));
     266             : static inline int vprintk(const char *s, va_list args) { return 0; }
     267             : static inline int printk(const char *s, ...)
     268             :         __attribute__ ((format (printf, 1, 2)));
     269             : static inline int __cold printk(const char *s, ...) { return 0; }
     270             : static inline int printk_ratelimit(void) { return 0; }
     271             : static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies, \
     272             :                                           unsigned int interval_msec)   \
     273             :                 { return false; }
     274             : 
     275             : /* No effect, but we still get type checking even in the !PRINTK case: */
     276             : #define printk_once(x...) printk(x)
     277             : 
     278             : static inline void log_buf_kexec_setup(void)
     279             : {
     280             : }
     281             : #endif
     282             : 
     283             : extern int printk_needs_cpu(int cpu);
     284             : extern void printk_tick(void);
     285             : 
     286             : extern void asmlinkage __attribute__((format(printf, 1, 2)))
     287             :         early_printk(const char *fmt, ...);
     288             : 
     289             : unsigned long int_sqrt(unsigned long);
     290             : 
     291             : static inline void console_silent(void)
     292             : {
     293             :         console_loglevel = 0;
     294             : }
     295             : 
     296             : static inline void console_verbose(void)
     297             : {
     298             :         if (console_loglevel)
     299             :                 console_loglevel = 15;
     300             : }
     301             : 
     302             : extern void bust_spinlocks(int yes);
     303             : extern void wake_up_klogd(void);
     304             : extern int oops_in_progress;            /* If set, an oops, panic(), BUG() or die() is in progress */
     305             : extern int panic_timeout;
     306             : extern int panic_on_oops;
     307             : extern int panic_on_unrecovered_nmi;
     308             : extern int panic_on_io_nmi;
     309             : extern const char *print_tainted(void);
     310             : extern void add_taint(unsigned flag);
     311             : extern int test_taint(unsigned flag);
     312             : extern unsigned long get_taint(void);
     313             : extern int root_mountflags;
     314             : 
     315             : /* Values used for system_state */
     316             : extern enum system_states {
     317             :         SYSTEM_BOOTING,
     318             :         SYSTEM_RUNNING,
     319             :         SYSTEM_HALT,
     320             :         SYSTEM_POWER_OFF,
     321             :         SYSTEM_RESTART,
     322             :         SYSTEM_SUSPEND_DISK,
     323             : } system_state;
     324             : 
     325             : #define TAINT_PROPRIETARY_MODULE        0
     326             : #define TAINT_FORCED_MODULE             1
     327             : #define TAINT_UNSAFE_SMP                2
     328             : #define TAINT_FORCED_RMMOD              3
     329             : #define TAINT_MACHINE_CHECK             4
     330             : #define TAINT_BAD_PAGE                  5
     331             : #define TAINT_USER                      6
     332             : #define TAINT_DIE                       7
     333             : #define TAINT_OVERRIDDEN_ACPI_TABLE     8
     334             : #define TAINT_WARN                      9
     335             : #define TAINT_CRAP                      10
     336             : 
     337             : extern void dump_stack(void) __cold;
     338             : 
     339             : enum {
     340             :         DUMP_PREFIX_NONE,
     341             :         DUMP_PREFIX_ADDRESS,
     342             :         DUMP_PREFIX_OFFSET
     343             : };
     344             : extern void hex_dump_to_buffer(const void *buf, size_t len,
     345             :                                 int rowsize, int groupsize,
     346             :                                 char *linebuf, size_t linebuflen, bool ascii);
     347             : extern void print_hex_dump(const char *level, const char *prefix_str,
     348             :                                 int prefix_type, int rowsize, int groupsize,
     349             :                                 const void *buf, size_t len, bool ascii);
     350             : extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
     351             :                         const void *buf, size_t len);
     352             : 
     353             : extern const char hex_asc[];
     354             : #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
     355             : #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
     356             : 
     357             : static inline char *pack_hex_byte(char *buf, u8 byte)
     358             : {
     359             :         *buf++ = hex_asc_hi(byte);
     360             :         *buf++ = hex_asc_lo(byte);
     361             :         return buf;
     362             : }
     363             : 
     364             : #ifndef pr_fmt
     365             : #define pr_fmt(fmt) fmt
     366             : #endif
     367             : 
     368             : #define pr_emerg(fmt, ...) \
     369             :         printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
     370             : #define pr_alert(fmt, ...) \
     371             :         printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
     372             : #define pr_crit(fmt, ...) \
     373             :         printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
     374             : #define pr_err(fmt, ...) \
     375             :         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
     376             : #define pr_warning(fmt, ...) \
     377             :         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
     378             : #define pr_notice(fmt, ...) \
     379             :         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
     380             : #define pr_info(fmt, ...) \
     381             :         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
     382             : #define pr_cont(fmt, ...) \
     383             :         printk(KERN_CONT fmt, ##__VA_ARGS__)
     384             : 
     385             : /* pr_devel() should produce zero code unless DEBUG is defined */
     386             : #ifdef DEBUG
     387             : #define pr_devel(fmt, ...) \
     388             :         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     389             : #else
     390             : #define pr_devel(fmt, ...) \
     391             :         ({ if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); 0; })
     392             : #endif
     393             : 
     394             : /* If you are writing a driver, please use dev_dbg instead */
     395             : #if defined(DEBUG)
     396             : #define pr_debug(fmt, ...) \
     397             :         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     398             : #elif defined(CONFIG_DYNAMIC_DEBUG)
     399             : /* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */
     400             : #define pr_debug(fmt, ...) \
     401             :         dynamic_pr_debug(fmt, ##__VA_ARGS__)
     402             : #else
     403             : #define pr_debug(fmt, ...) \
     404             :         ({ if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); 0; })
     405             : #endif
     406             : 
     407             : /*
     408             :  * ratelimited messages with local ratelimit_state,
     409             :  * no local ratelimit_state used in the !PRINTK case
     410             :  */
     411             : #ifdef CONFIG_PRINTK
     412             : #define printk_ratelimited(fmt, ...)  ({                \
     413             :         static struct ratelimit_state _rs = {           \
     414             :                 .interval = DEFAULT_RATELIMIT_INTERVAL, \
     415             :                 .burst = DEFAULT_RATELIMIT_BURST,       \
     416             :         };                                              \
     417             :                                                         \
     418             :         if (!__ratelimit(&_rs))                         \
     419             :                 printk(fmt, ##__VA_ARGS__);             \
     420             : })
     421             : #else
     422             : /* No effect, but we still get type checking even in the !PRINTK case: */
     423             : #define printk_ratelimited printk
     424             : #endif
     425             : 
     426             : #define pr_emerg_ratelimited(fmt, ...) \
     427             :         printk_ratelimited(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
     428             : #define pr_alert_ratelimited(fmt, ...) \
     429             :         printk_ratelimited(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
     430             : #define pr_crit_ratelimited(fmt, ...) \
     431             :         printk_ratelimited(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
     432             : #define pr_err_ratelimited(fmt, ...) \
     433             :         printk_ratelimited(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
     434             : #define pr_warning_ratelimited(fmt, ...) \
     435             :         printk_ratelimited(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
     436             : #define pr_notice_ratelimited(fmt, ...) \
     437             :         printk_ratelimited(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
     438             : #define pr_info_ratelimited(fmt, ...) \
     439             :         printk_ratelimited(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
     440             : /* no pr_cont_ratelimited, don't do that... */
     441             : /* If you are writing a driver, please use dev_dbg instead */
     442             : #if defined(DEBUG)
     443             : #define pr_debug_ratelimited(fmt, ...) \
     444             :         printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
     445             : #else
     446             : #define pr_debug_ratelimited(fmt, ...) \
     447             :         ({ if (0) printk_ratelimited(KERN_DEBUG pr_fmt(fmt), \
     448             :                                      ##__VA_ARGS__); 0; })
     449             : #endif
     450             : 
     451             : /*
     452             :  * General tracing related utility functions - trace_printk(),
     453             :  * tracing_on/tracing_off and tracing_start()/tracing_stop
     454             :  *
     455             :  * Use tracing_on/tracing_off when you want to quickly turn on or off
     456             :  * tracing. It simply enables or disables the recording of the trace events.
     457             :  * This also corresponds to the user space /sys/kernel/debug/tracing/tracing_on
     458             :  * file, which gives a means for the kernel and userspace to interact.
     459             :  * Place a tracing_off() in the kernel where you want tracing to end.
     460             :  * From user space, examine the trace, and then echo 1 > tracing_on
     461             :  * to continue tracing.
     462             :  *
     463             :  * tracing_stop/tracing_start has slightly more overhead. It is used
     464             :  * by things like suspend to ram where disabling the recording of the
     465             :  * trace is not enough, but tracing must actually stop because things
     466             :  * like calling smp_processor_id() may crash the system.
     467             :  *
     468             :  * Most likely, you want to use tracing_on/tracing_off.
     469             :  */
     470             : #ifdef CONFIG_RING_BUFFER
     471             : void tracing_on(void);
     472             : void tracing_off(void);
     473             : /* trace_off_permanent stops recording with no way to bring it back */
     474             : void tracing_off_permanent(void);
     475             : int tracing_is_on(void);
     476             : #else
     477             : static inline void tracing_on(void) { }
     478             : static inline void tracing_off(void) { }
     479             : static inline void tracing_off_permanent(void) { }
     480             : static inline int tracing_is_on(void) { return 0; }
     481             : #endif
     482             : #ifdef CONFIG_TRACING
     483             : extern void tracing_start(void);
     484             : extern void tracing_stop(void);
     485             : extern void ftrace_off_permanent(void);
     486             : 
     487             : extern void
     488             : ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
     489             : 
     490             : static inline void __attribute__ ((format (printf, 1, 2)))
     491             : ____trace_printk_check_format(const char *fmt, ...)
     492             : {
     493             : }
     494             : #define __trace_printk_check_format(fmt, args...)                       \
     495             : do {                                                                    \
     496             :         if (0)                                                          \
     497             :                 ____trace_printk_check_format(fmt, ##args);             \
     498             : } while (0)
     499             : 
     500             : /**
     501             :  * trace_printk - printf formatting in the ftrace buffer
     502             :  * @fmt: the printf format for printing
     503             :  *
     504             :  * Note: __trace_printk is an internal function for trace_printk and
     505             :  *       the @ip is passed in via the trace_printk macro.
     506             :  *
     507             :  * This function allows a kernel developer to debug fast path sections
     508             :  * that printk is not appropriate for. By scattering in various
     509             :  * printk like tracing in the code, a developer can quickly see
     510             :  * where problems are occurring.
     511             :  *
     512             :  * This is intended as a debugging tool for the developer only.
     513             :  * Please refrain from leaving trace_printks scattered around in
     514             :  * your code.
     515             :  */
     516             : 
     517             : #define trace_printk(fmt, args...)                                      \
     518             : do {                                                                    \
     519             :         __trace_printk_check_format(fmt, ##args);                       \
     520             :         if (__builtin_constant_p(fmt)) {                                \
     521             :                 static const char *trace_printk_fmt                     \
     522             :                   __attribute__((section("__trace_printk_fmt"))) =    \
     523             :                         __builtin_constant_p(fmt) ? fmt : NULL;         \
     524             :                                                                         \
     525             :                 __trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args);   \
     526             :         } else                                                          \
     527             :                 __trace_printk(_THIS_IP_, fmt, ##args);         \
     528             : } while (0)
     529             : 
     530             : extern int
     531             : __trace_bprintk(unsigned long ip, const char *fmt, ...)
     532             :         __attribute__ ((format (printf, 2, 3)));
     533             : 
     534             : extern int
     535             : __trace_printk(unsigned long ip, const char *fmt, ...)
     536             :         __attribute__ ((format (printf, 2, 3)));
     537             : 
     538             : extern void trace_dump_stack(void);
     539             : 
     540             : /*
     541             :  * The double __builtin_constant_p is because gcc will give us an error
     542             :  * if we try to allocate the static variable to fmt if it is not a
     543             :  * constant. Even with the outer if statement.
     544             :  */
     545             : #define ftrace_vprintk(fmt, vargs)                                      \
     546             : do {                                                                    \
     547             :         if (__builtin_constant_p(fmt)) {                                \
     548             :                 static const char *trace_printk_fmt                     \
     549             :                   __attribute__((section("__trace_printk_fmt"))) =    \
     550             :                         __builtin_constant_p(fmt) ? fmt : NULL;         \
     551             :                                                                         \
     552             :                 __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs);  \
     553             :         } else                                                          \
     554             :                 __ftrace_vprintk(_THIS_IP_, fmt, vargs);                \
     555             : } while (0)
     556             : 
     557             : extern int
     558             : __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
     559             : 
     560             : extern int
     561             : __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
     562             : 
     563             : extern void ftrace_dump(void);
     564             : #else
     565             : static inline void
     566             : ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
     567             : static inline int
     568             : trace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
     569             : 
     570             : static inline void tracing_start(void) { }
     571             : static inline void tracing_stop(void) { }
     572             : static inline void ftrace_off_permanent(void) { }
     573             : static inline void trace_dump_stack(void) { }
     574             : static inline int
     575             : trace_printk(const char *fmt, ...)
     576             : {
     577             :         return 0;
     578             : }
     579             : static inline int
     580             : ftrace_vprintk(const char *fmt, va_list ap)
     581             : {
     582             :         return 0;
     583             : }
     584             : static inline void ftrace_dump(void) { }
     585             : #endif /* CONFIG_TRACING */
     586             : 
     587             : /*
     588             :  *      Display an IP address in readable format.
     589             :  */
     590             : 
     591             : #define NIPQUAD(addr) \
     592             :         ((unsigned char *)&addr)[0], \
     593             :         ((unsigned char *)&addr)[1], \
     594             :         ((unsigned char *)&addr)[2], \
     595             :         ((unsigned char *)&addr)[3]
     596             : #define NIPQUAD_FMT "%u.%u.%u.%u"
     597             : 
     598             : /*
     599             :  * min()/max()/clamp() macros that also do
     600             :  * strict type-checking.. See the
     601             :  * "unnecessary" pointer comparison.
     602             :  */
     603             : #define min(x, y) ({                            \
     604             :         typeof(x) _min1 = (x);                  \
     605             :         typeof(y) _min2 = (y);                  \
     606             :         (void) (&_min1 == &_min2);              \
     607             :         _min1 < _min2 ? _min1 : _min2; })
     608             : 
     609             : #define max(x, y) ({                            \
     610             :         typeof(x) _max1 = (x);                  \
     611             :         typeof(y) _max2 = (y);                  \
     612             :         (void) (&_max1 == &_max2);              \
     613             :         _max1 > _max2 ? _max1 : _max2; })
     614             : 
     615             : /**
     616             :  * clamp - return a value clamped to a given range with strict typechecking
     617             :  * @val: current value
     618             :  * @min: minimum allowable value
     619             :  * @max: maximum allowable value
     620             :  *
     621             :  * This macro does strict typechecking of min/max to make sure they are of the
     622             :  * same type as val.  See the unnecessary pointer comparisons.
     623             :  */
     624             : #define clamp(val, min, max) ({                 \
     625             :         typeof(val) __val = (val);              \
     626             :         typeof(min) __min = (min);              \
     627             :         typeof(max) __max = (max);              \
     628             :         (void) (&__val == &__min);              \
     629             :         (void) (&__val == &__max);              \
     630             :         __val = __val < __min ? __min: __val;        \
     631             :         __val > __max ? __max: __val; })
     632             : 
     633             : /*
     634             :  * ..and if you can't take the strict
     635             :  * types, you can specify one yourself.
     636             :  *
     637             :  * Or not use min/max/clamp at all, of course.
     638             :  */
     639             : #define min_t(type, x, y) ({                    \
     640             :         type __min1 = (x);                      \
     641             :         type __min2 = (y);                      \
     642             :         __min1 < __min2 ? __min1: __min2; })
     643             : 
     644             : #define max_t(type, x, y) ({                    \
     645             :         type __max1 = (x);                      \
     646             :         type __max2 = (y);                      \
     647             :         __max1 > __max2 ? __max1: __max2; })
     648             : 
     649             : /**
     650             :  * clamp_t - return a value clamped to a given range using a given type
     651             :  * @type: the type of variable to use
     652             :  * @val: current value
     653             :  * @min: minimum allowable value
     654             :  * @max: maximum allowable value
     655             :  *
     656             :  * This macro does no typechecking and uses temporary variables of type
     657             :  * 'type' to make all the comparisons.
     658             :  */
     659             : #define clamp_t(type, val, min, max) ({         \
     660             :         type __val = (val);                     \
     661             :         type __min = (min);                     \
     662             :         type __max = (max);                     \
     663             :         __val = __val < __min ? __min: __val;        \
     664             :         __val > __max ? __max: __val; })
     665             : 
     666             : /**
     667             :  * clamp_val - return a value clamped to a given range using val's type
     668             :  * @val: current value
     669             :  * @min: minimum allowable value
     670             :  * @max: maximum allowable value
     671             :  *
     672             :  * This macro does no typechecking and uses temporary variables of whatever
     673             :  * type the input argument 'val' is.  This is useful when val is an unsigned
     674             :  * type and min and max are literals that will otherwise be assigned a signed
     675             :  * integer type.
     676             :  */
     677             : #define clamp_val(val, min, max) ({             \
     678             :         typeof(val) __val = (val);              \
     679             :         typeof(val) __min = (min);              \
     680             :         typeof(val) __max = (max);              \
     681             :         __val = __val < __min ? __min: __val;        \
     682             :         __val > __max ? __max: __val; })
     683             : 
     684             : 
     685             : /*
     686             :  * swap - swap value of @a and @b
     687             :  */
     688             : #define swap(a, b) \
     689             :         do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
     690             : 
     691             : /**
     692             :  * container_of - cast a member of a structure out to the containing structure
     693             :  * @ptr:        the pointer to the member.
     694             :  * @type:       the type of the container struct this is embedded in.
     695             :  * @member:     the name of the member within the struct.
     696             :  *
     697             :  */
     698             : #define container_of(ptr, type, member) ({                      \
     699             :         const typeof( ((type *)0)->member ) *__mptr = (ptr); \
     700             :         (type *)( (char *)__mptr - offsetof(type,member) );})
     701             : 
     702             : struct sysinfo;
     703             : extern int do_sysinfo(struct sysinfo *info);
     704             : 
     705             : #endif /* __KERNEL__ */
     706             : 
     707             : #ifndef __EXPORTED_HEADERS__
     708             : #ifndef __KERNEL__
     709             : #warning Attempt to use kernel headers from user space, see http://kernelnewbies.org/KernelHeaders
     710             : #endif /* __KERNEL__ */
     711             : #endif /* __EXPORTED_HEADERS__ */
     712             : 
     713             : #define SI_LOAD_SHIFT   16
     714             : struct sysinfo {
     715             :         long uptime;                    /* Seconds since boot */
     716             :         unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
     717             :         unsigned long totalram;         /* Total usable main memory size */
     718             :         unsigned long freeram;          /* Available memory size */
     719             :         unsigned long sharedram;        /* Amount of shared memory */
     720             :         unsigned long bufferram;        /* Memory used by buffers */
     721             :         unsigned long totalswap;        /* Total swap space size */
     722             :         unsigned long freeswap;         /* swap space still available */
     723             :         unsigned short procs;           /* Number of current processes */
     724             :         unsigned short pad;             /* explicit padding for m68k */
     725             :         unsigned long totalhigh;        /* Total high memory size */
     726             :         unsigned long freehigh;         /* Available high memory size */
     727             :         unsigned int mem_unit;          /* Memory unit size in bytes */
     728             :         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
     729             : };
     730             : 
     731             : /* Force a compilation error if condition is true */
     732             : #define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition))
     733             : 
     734             : /* Force a compilation error if condition is constant and true */
     735             : #define MAYBE_BUILD_BUG_ON(cond) ((void)sizeof(char[1 - 2 * !!(cond)]))
     736             : 
     737             : /* Force a compilation error if a constant expression is not a power of 2 */
     738             : #define BUILD_BUG_ON_NOT_POWER_OF_2(n)                  \
     739             :         BUILD_BUG_ON((n) == 0 || (((n) & ((n) - 1)) != 0))
     740             : 
     741             : /* Force a compilation error if condition is true, but also produce a
     742             :    result (of value 0 and type size_t), so the expression can be used
     743             :    e.g. in a structure initializer (or where-ever else comma expressions
     744             :    aren't permitted). */
     745             : #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
     746             : #define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); }))
     747             : 
     748             : /* Trap pasters of __FUNCTION__ at compile-time */
     749             : #define __FUNCTION__ (__func__)
     750             : 
     751             : /* This helps us to avoid #ifdef CONFIG_NUMA */
     752             : #ifdef CONFIG_NUMA
     753             : #define NUMA_BUILD 1
     754             : #else
     755             : #define NUMA_BUILD 0
     756             : #endif
     757             : 
     758             : /* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */
     759             : #ifdef CONFIG_FTRACE_MCOUNT_RECORD
     760             : # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
     761             : #endif
     762             : 
     763             : #endif

Generated by: LCOV version 1.10