1,22 → 1,19 |
#ifndef _LINUX_KERNEL_H |
#define _LINUX_KERNEL_H |
|
/* |
* 'kernel.h' contains some often-used function prototypes etc |
*/ |
|
#ifdef __KERNEL__ |
|
#include <stdarg.h> |
#include <linux/linkage.h> |
#include <linux/stddef.h> |
#include <linux/types.h> |
#include <linux/compiler.h> |
#include <linux/bitops.h> |
#include <linux/errno.h> |
#include <linux/log2.h> |
#include <linux/typecheck.h> |
#include <linux/printk.h> |
#include <asm/byteorder.h> |
#include <uapi/linux/kernel.h> |
|
#define __init |
|
#define USHRT_MAX ((u16)(~0U)) |
#define SHRT_MAX ((s16)(USHRT_MAX>>1)) |
#define SHRT_MIN ((s16)(-SHRT_MAX - 1)) |
44,8 → 41,12 |
#define S64_MAX ((s64)(U64_MAX>>1)) |
#define S64_MIN ((s64)(-S64_MAX - 1)) |
|
#define ALIGN(x,a) __ALIGN_MASK(x,(typeof(x))(a)-1) |
#define __ALIGN_MASK(x,mask) (((x)+(mask))&~(mask)) |
#define STACK_MAGIC 0xdeadbeef |
|
#define REPEAT_BYTE(x) ((~0ul / 0xff) * (x)) |
|
#define ALIGN(x, a) __ALIGN_KERNEL((x), (a)) |
#define __ALIGN_MASK(x, mask) __ALIGN_KERNEL_MASK((x), (mask)) |
#define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a))) |
#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0) |
|
114,14 → 115,23 |
} \ |
) |
|
#define clamp_t(type, val, min, max) ({ \ |
type __val = (val); \ |
type __min = (min); \ |
type __max = (max); \ |
__val = __val < __min ? __min: __val; \ |
__val > __max ? __max: __val; }) |
|
#define _RET_IP_ (unsigned long)__builtin_return_address(0) |
#define _THIS_IP_ ({ __label__ __here; __here: (unsigned long)&&__here; }) |
|
#ifdef CONFIG_LBDAF |
# include <asm/div64.h> |
# define sector_div(a, b) do_div(a, b) |
#else |
# define sector_div(n, b)( \ |
{ \ |
int _res; \ |
_res = (n) % (b); \ |
(n) /= (b); \ |
_res; \ |
} \ |
) |
#endif |
|
/** |
* upper_32_bits - return bits 32-63 of a number |
140,6 → 150,23 |
#define lower_32_bits(n) ((u32)(n)) |
|
|
/* |
* abs() handles unsigned and signed longs, ints, shorts and chars. For all |
* input types abs() returns a signed long. |
* abs() should not be used for 64-bit types (s64, u64, long long) - use abs64() |
* for those. |
*/ |
#define abs(x) ({ \ |
long ret; \ |
if (sizeof(x) == sizeof(long)) { \ |
long __x = (x); \ |
ret = (__x < 0) ? -__x : __x; \ |
} else { \ |
int __x = (x); \ |
ret = (__x < 0) ? -__x : __x; \ |
} \ |
ret; \ |
}) |
|
#define abs64(x) ({ \ |
s64 __x = (x); \ |
154,11 → 181,60 |
#define KERN_NOTICE "<5>" /* normal but significant condition */ |
#define KERN_INFO "<6>" /* informational */ |
#define KERN_DEBUG "<7>" /* debug-level messages */ |
extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...); |
extern __printf(2, 0) int vsprintf(char *buf, const char *, va_list); |
extern __printf(3, 4) |
int snprintf(char *buf, size_t size, const char *fmt, ...); |
extern __printf(3, 0) |
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args); |
extern __printf(3, 4) |
int scnprintf(char *buf, size_t size, const char *fmt, ...); |
extern __printf(3, 0) |
int vscnprintf(char *buf, size_t size, const char *fmt, va_list args); |
extern __printf(2, 3) |
char *kasprintf(gfp_t gfp, const char *fmt, ...); |
extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args); |
enum lockdep_ok { |
LOCKDEP_STILL_OK, |
LOCKDEP_NOW_UNRELIABLE |
}; |
extern void add_taint(unsigned flag, enum lockdep_ok); |
extern int test_taint(unsigned flag); |
extern unsigned long get_taint(void); |
extern int root_mountflags; |
|
extern bool early_boot_irqs_disabled; |
|
/* Values used for system_state */ |
extern enum system_states { |
SYSTEM_BOOTING, |
SYSTEM_RUNNING, |
SYSTEM_HALT, |
SYSTEM_POWER_OFF, |
SYSTEM_RESTART, |
} system_state; |
|
#define TAINT_PROPRIETARY_MODULE 0 |
#define TAINT_FORCED_MODULE 1 |
#define TAINT_CPU_OUT_OF_SPEC 2 |
#define TAINT_FORCED_RMMOD 3 |
#define TAINT_MACHINE_CHECK 4 |
#define TAINT_BAD_PAGE 5 |
#define TAINT_USER 6 |
#define TAINT_DIE 7 |
#define TAINT_OVERRIDDEN_ACPI_TABLE 8 |
#define TAINT_WARN 9 |
#define TAINT_CRAP 10 |
#define TAINT_FIRMWARE_WORKAROUND 11 |
#define TAINT_OOT_MODULE 12 |
#define TAINT_UNSIGNED_MODULE 13 |
#define TAINT_SOFTLOCKUP 14 |
|
extern const char hex_asc[]; |
#define hex_asc_lo(x) hex_asc[((x) & 0x0f)] |
#define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4] |
|
static inline char *pack_hex_byte(char *buf, u8 byte) |
static inline char *hex_byte_pack(char *buf, u8 byte) |
{ |
*buf++ = hex_asc_hi(byte); |
*buf++ = hex_asc_lo(byte); |
165,25 → 241,223 |
return buf; |
} |
|
enum { |
DUMP_PREFIX_NONE, |
DUMP_PREFIX_ADDRESS, |
DUMP_PREFIX_OFFSET |
extern const char hex_asc_upper[]; |
#define hex_asc_upper_lo(x) hex_asc_upper[((x) & 0x0f)] |
#define hex_asc_upper_hi(x) hex_asc_upper[((x) & 0xf0) >> 4] |
|
static inline char *hex_byte_pack_upper(char *buf, u8 byte) |
{ |
*buf++ = hex_asc_upper_hi(byte); |
*buf++ = hex_asc_upper_lo(byte); |
return buf; |
} |
|
extern int hex_to_bin(char ch); |
extern int __must_check hex2bin(u8 *dst, const char *src, size_t count); |
extern char *bin2hex(char *dst, const void *src, size_t count); |
|
bool mac_pton(const char *s, u8 *mac); |
|
/* |
* General tracing related utility functions - trace_printk(), |
* tracing_on/tracing_off and tracing_start()/tracing_stop |
* |
* Use tracing_on/tracing_off when you want to quickly turn on or off |
* tracing. It simply enables or disables the recording of the trace events. |
* This also corresponds to the user space /sys/kernel/debug/tracing/tracing_on |
* file, which gives a means for the kernel and userspace to interact. |
* Place a tracing_off() in the kernel where you want tracing to end. |
* From user space, examine the trace, and then echo 1 > tracing_on |
* to continue tracing. |
* |
* tracing_stop/tracing_start has slightly more overhead. It is used |
* by things like suspend to ram where disabling the recording of the |
* trace is not enough, but tracing must actually stop because things |
* like calling smp_processor_id() may crash the system. |
* |
* Most likely, you want to use tracing_on/tracing_off. |
*/ |
#ifdef CONFIG_RING_BUFFER |
/* trace_off_permanent stops recording with no way to bring it back */ |
void tracing_off_permanent(void); |
#else |
static inline void tracing_off_permanent(void) { } |
#endif |
|
enum ftrace_dump_mode { |
DUMP_NONE, |
DUMP_ALL, |
DUMP_ORIG, |
}; |
|
int hex_to_bin(char ch); |
int hex2bin(u8 *dst, const char *src, size_t count); |
#ifdef CONFIG_TRACING |
void tracing_on(void); |
void tracing_off(void); |
int tracing_is_on(void); |
void tracing_snapshot(void); |
void tracing_snapshot_alloc(void); |
|
extern void tracing_start(void); |
extern void tracing_stop(void); |
|
//int printk(const char *fmt, ...); |
static inline __printf(1, 2) |
void ____trace_printk_check_format(const char *fmt, ...) |
{ |
} |
#define __trace_printk_check_format(fmt, args...) \ |
do { \ |
if (0) \ |
____trace_printk_check_format(fmt, ##args); \ |
} while (0) |
|
#define printk(fmt, arg...) dbgprintf(fmt , ##arg) |
/** |
* trace_printk - printf formatting in the ftrace buffer |
* @fmt: the printf format for printing |
* |
* Note: __trace_printk is an internal function for trace_printk and |
* the @ip is passed in via the trace_printk macro. |
* |
* This function allows a kernel developer to debug fast path sections |
* that printk is not appropriate for. By scattering in various |
* printk like tracing in the code, a developer can quickly see |
* where problems are occurring. |
* |
* This is intended as a debugging tool for the developer only. |
* Please refrain from leaving trace_printks scattered around in |
* your code. (Extra memory is used for special buffers that are |
* allocated when trace_printk() is used) |
* |
* A little optization trick is done here. If there's only one |
* argument, there's no need to scan the string for printf formats. |
* The trace_puts() will suffice. But how can we take advantage of |
* using trace_puts() when trace_printk() has only one argument? |
* By stringifying the args and checking the size we can tell |
* whether or not there are args. __stringify((__VA_ARGS__)) will |
* turn into "()\0" with a size of 3 when there are no args, anything |
* else will be bigger. All we need to do is define a string to this, |
* and then take its size and compare to 3. If it's bigger, use |
* do_trace_printk() otherwise, optimize it to trace_puts(). Then just |
* let gcc optimize the rest. |
*/ |
|
extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...); |
#define trace_printk(fmt, ...) \ |
do { \ |
char _______STR[] = __stringify((__VA_ARGS__)); \ |
if (sizeof(_______STR) > 3) \ |
do_trace_printk(fmt, ##__VA_ARGS__); \ |
else \ |
trace_puts(fmt); \ |
} while (0) |
|
#define do_trace_printk(fmt, args...) \ |
do { \ |
static const char *trace_printk_fmt \ |
__attribute__((section("__trace_printk_fmt"))) = \ |
__builtin_constant_p(fmt) ? fmt : NULL; \ |
\ |
__trace_printk_check_format(fmt, ##args); \ |
\ |
if (__builtin_constant_p(fmt)) \ |
__trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args); \ |
else \ |
__trace_printk(_THIS_IP_, fmt, ##args); \ |
} while (0) |
|
extern __printf(2, 3) |
char *kasprintf(gfp_t gfp, const char *fmt, ...); |
int __trace_bprintk(unsigned long ip, const char *fmt, ...); |
|
extern __printf(2, 3) |
int __trace_printk(unsigned long ip, const char *fmt, ...); |
|
/** |
* trace_puts - write a string into the ftrace buffer |
* @str: the string to record |
* |
* Note: __trace_bputs is an internal function for trace_puts and |
* the @ip is passed in via the trace_puts macro. |
* |
* This is similar to trace_printk() but is made for those really fast |
* paths that a developer wants the least amount of "Heisenbug" affects, |
* where the processing of the print format is still too much. |
* |
* This function allows a kernel developer to debug fast path sections |
* that printk is not appropriate for. By scattering in various |
* printk like tracing in the code, a developer can quickly see |
* where problems are occurring. |
* |
* This is intended as a debugging tool for the developer only. |
* Please refrain from leaving trace_puts scattered around in |
* your code. (Extra memory is used for special buffers that are |
* allocated when trace_puts() is used) |
* |
* Returns: 0 if nothing was written, positive # if string was. |
* (1 when __trace_bputs is used, strlen(str) when __trace_puts is used) |
*/ |
|
#define trace_puts(str) ({ \ |
static const char *trace_printk_fmt \ |
__attribute__((section("__trace_printk_fmt"))) = \ |
__builtin_constant_p(str) ? str : NULL; \ |
\ |
if (__builtin_constant_p(str)) \ |
__trace_bputs(_THIS_IP_, trace_printk_fmt); \ |
else \ |
__trace_puts(_THIS_IP_, str, strlen(str)); \ |
}) |
extern int __trace_bputs(unsigned long ip, const char *str); |
extern int __trace_puts(unsigned long ip, const char *str, int size); |
|
extern void trace_dump_stack(int skip); |
|
/* |
* The double __builtin_constant_p is because gcc will give us an error |
* if we try to allocate the static variable to fmt if it is not a |
* constant. Even with the outer if statement. |
*/ |
#define ftrace_vprintk(fmt, vargs) \ |
do { \ |
if (__builtin_constant_p(fmt)) { \ |
static const char *trace_printk_fmt \ |
__attribute__((section("__trace_printk_fmt"))) = \ |
__builtin_constant_p(fmt) ? fmt : NULL; \ |
\ |
__ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs); \ |
} else \ |
__ftrace_vprintk(_THIS_IP_, fmt, vargs); \ |
} while (0) |
|
extern int |
__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap); |
|
extern int |
__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap); |
|
extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode); |
#else |
static inline void tracing_start(void) { } |
static inline void tracing_stop(void) { } |
static inline void trace_dump_stack(int skip) { } |
|
static inline void tracing_on(void) { } |
static inline void tracing_off(void) { } |
static inline int tracing_is_on(void) { return 0; } |
static inline void tracing_snapshot(void) { } |
static inline void tracing_snapshot_alloc(void) { } |
|
static inline __printf(1, 2) |
int trace_printk(const char *fmt, ...) |
{ |
return 0; |
} |
static inline int |
ftrace_vprintk(const char *fmt, va_list ap) |
{ |
return 0; |
} |
static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { } |
#endif /* CONFIG_TRACING */ |
|
/* |
* min()/max()/clamp() macros that also do |
* strict type-checking.. See the |
* "unnecessary" pointer comparison. |
200,24 → 474,9 |
(void) (&_max1 == &_max2); \ |
_max1 > _max2 ? _max1 : _max2; }) |
|
#define min3(x, y, z) ({ \ |
typeof(x) _min1 = (x); \ |
typeof(y) _min2 = (y); \ |
typeof(z) _min3 = (z); \ |
(void) (&_min1 == &_min2); \ |
(void) (&_min1 == &_min3); \ |
_min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \ |
(_min2 < _min3 ? _min2 : _min3); }) |
#define min3(x, y, z) min((typeof(x))min(x, y), z) |
#define max3(x, y, z) max((typeof(x))max(x, y), z) |
|
#define max3(x, y, z) ({ \ |
typeof(x) _max1 = (x); \ |
typeof(y) _max2 = (y); \ |
typeof(z) _max3 = (z); \ |
(void) (&_max1 == &_max2); \ |
(void) (&_max1 == &_max3); \ |
_max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \ |
(_max2 > _max3 ? _max2 : _max3); }) |
|
/** |
* min_not_zero - return the minimum that is _not_ zero, unless both are zero |
* @x: value1 |
231,20 → 490,13 |
/** |
* clamp - return a value clamped to a given range with strict typechecking |
* @val: current value |
* @min: minimum allowable value |
* @max: maximum allowable value |
* @lo: lowest allowable value |
* @hi: highest allowable value |
* |
* This macro does strict typechecking of min/max to make sure they are of the |
* This macro does strict typechecking of lo/hi to make sure they are of the |
* same type as val. See the unnecessary pointer comparisons. |
*/ |
#define clamp(val, min, max) ({ \ |
typeof(val) __val = (val); \ |
typeof(min) __min = (min); \ |
typeof(max) __max = (max); \ |
(void) (&__val == &__min); \ |
(void) (&__val == &__max); \ |
__val = __val < __min ? __min: __val; \ |
__val > __max ? __max: __val; }) |
#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) |
|
/* |
* ..and if you can't take the strict |
263,6 → 515,38 |
__max1 > __max2 ? __max1: __max2; }) |
|
/** |
* clamp_t - return a value clamped to a given range using a given type |
* @type: the type of variable to use |
* @val: current value |
* @lo: minimum allowable value |
* @hi: maximum allowable value |
* |
* This macro does no typechecking and uses temporary variables of type |
* 'type' to make all the comparisons. |
*/ |
#define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi) |
|
/** |
* clamp_val - return a value clamped to a given range using val's type |
* @val: current value |
* @lo: minimum allowable value |
* @hi: maximum allowable value |
* |
* This macro does no typechecking and uses temporary variables of whatever |
* type the input argument 'val' is. This is useful when val is an unsigned |
* type and min and max are literals that will otherwise be assigned a signed |
* integer type. |
*/ |
#define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi) |
|
|
/* |
* swap - swap value of @a and @b |
*/ |
#define swap(a, b) \ |
do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) |
|
/** |
* container_of - cast a member of a structure out to the containing structure |
* @ptr: the pointer to the member. |
* @type: the type of the container struct this is embedded in. |
273,22 → 557,28 |
const typeof( ((type *)0)->member ) *__mptr = (ptr); \ |
(type *)( (char *)__mptr - offsetof(type,member) );}) |
|
/* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */ |
#ifdef CONFIG_FTRACE_MCOUNT_RECORD |
# define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD |
#endif |
|
static inline void *kcalloc(size_t n, size_t size, uint32_t flags) |
{ |
if (n != 0 && size > ULONG_MAX / n) |
return NULL; |
return kzalloc(n * size, 0); |
} |
/* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */ |
#define VERIFY_OCTAL_PERMISSIONS(perms) \ |
(BUILD_BUG_ON_ZERO((perms) < 0) + \ |
BUILD_BUG_ON_ZERO((perms) > 0777) + \ |
/* User perms >= group perms >= other perms */ \ |
BUILD_BUG_ON_ZERO(((perms) >> 6) < (((perms) >> 3) & 7)) + \ |
BUILD_BUG_ON_ZERO((((perms) >> 3) & 7) < ((perms) & 7)) + \ |
/* Other writable? Generally considered a bad idea. */ \ |
BUILD_BUG_ON_ZERO((perms) & 2) + \ |
(perms)) |
|
|
void free (void *ptr); |
|
#endif /* __KERNEL__ */ |
|
typedef unsigned long pgprotval_t; |
|
typedef struct pgprot { pgprotval_t pgprot; } pgprot_t; |
|
struct file |
{ |
352,17 → 642,7 |
|
# define del_timer_sync(t) del_timer(t) |
|
struct timespec { |
long tv_sec; /* seconds */ |
long tv_nsec; /* nanoseconds */ |
}; |
|
|
#define mb() asm volatile("mfence" : : : "memory") |
#define rmb() asm volatile("lfence" : : : "memory") |
#define wmb() asm volatile("sfence" : : : "memory") |
|
|
#define build_mmio_read(name, size, type, reg, barrier) \ |
static inline type name(const volatile void __iomem *addr) \ |
{ type ret; asm volatile("mov" size " %1,%0":reg (ret) \ |
400,23 → 680,6 |
#define __raw_writew __writew |
#define __raw_writel __writel |
|
static inline __u64 readq(const volatile void __iomem *addr) |
{ |
const volatile u32 __iomem *p = addr; |
u32 low, high; |
|
low = readl(p); |
high = readl(p + 1); |
|
return low + ((u64)high << 32); |
} |
|
static inline void writeq(__u64 val, volatile void __iomem *addr) |
{ |
writel(val, addr); |
writel(val >> 32, addr+4); |
} |
|
#define swap(a, b) \ |
do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) |
|
432,9 → 695,6 |
#define dev_info(dev, format, arg...) \ |
printk("Info %s " format , __func__, ## arg) |
|
//#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) |
#define BUILD_BUG_ON(condition) |
|
struct page |
{ |
unsigned int addr; |
467,8 → 727,6 |
|
#define get_page(a) |
#define put_page(a) |
#define set_pages_uc(a,b) |
#define set_pages_wb(a,b) |
|
#define pci_map_page(dev, page, offset, size, direction) \ |
(dma_addr_t)( (offset)+page_to_phys(page)) |
475,36 → 733,31 |
|
#define pci_unmap_page(dev, dma_address, size, direction) |
|
#define GFP_TEMPORARY 0 |
#define __GFP_NOWARN 0 |
#define __GFP_NORETRY 0 |
#define GFP_NOWAIT 0 |
|
#define IS_ENABLED(a) 0 |
|
|
#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x)) |
|
#define RCU_INIT_POINTER(p, v) \ |
do { \ |
p = (typeof(*v) __force __rcu *)(v); \ |
} while (0) |
//#define RCU_INIT_POINTER(p, v) \ |
// do { \ |
// p = (typeof(*v) __force __rcu *)(v); \ |
// } while (0) |
|
|
#define rcu_dereference_raw(p) ({ \ |
typeof(p) _________p1 = ACCESS_ONCE(p); \ |
(_________p1); \ |
}) |
#define rcu_assign_pointer(p, v) \ |
({ \ |
if (!__builtin_constant_p(v) || \ |
((v) != NULL)) \ |
(p) = (v); \ |
}) |
//#define rcu_dereference_raw(p) ({ \ |
// typeof(p) _________p1 = ACCESS_ONCE(p); \ |
// (_________p1); \ |
// }) |
|
//#define rcu_assign_pointer(p, v) \ |
// ({ \ |
// if (!__builtin_constant_p(v) || \ |
// ((v) != NULL)) \ |
// (p) = (v); \ |
// }) |
|
unsigned int hweight16(unsigned int w); |
|
|
#define cpufreq_quick_get_max(x) GetCpuFreq() |
|
extern unsigned int tsc_khz; |
540,7 → 793,7 |
} |
} |
|
memcpy((void __force *)to, from, n); |
__builtin_memcpy((void __force *)to, from, n); |
return 0; |
} |
|
551,6 → 804,14 |
void kunmap(struct page *page); |
void kunmap_atomic(void *vaddr); |
|
typedef u64 async_cookie_t; |
|
#define iowrite32(v, addr) writel((v), (addr)) |
|
|
#define __init |
|
#define CONFIG_PAGE_OFFSET 0 |
|
|
#endif |
|