WebSVN – Kolibri OS – Diff – /drivers/include/linux/kernel.h

 #ifndef _LINUX_KERNEL_H
 #define _LINUX_KERNEL_H
-/*
- * 'kernel.h' contains some often-used function prototypes etc
- */
 #ifdef __KERNEL__
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
-#define __init
+#include
+#include
+#include
 #define USHRT_MAX	((u16)(~0U))
 #define SHRT_MAX	((s16)(USHRT_MAX>>1))
 #define SHRT_MIN	((s16)(-SHRT_MAX - 1))
 #define INT_MAX     ((int)(~0U>>1))
 #define INT_MIN     (-INT_MAX - 1)
 #define UINT_MAX    (~0U)
 #define LONG_MAX    ((long)(~0UL>>1))
 #define LONG_MIN    (-LONG_MAX - 1)
 #define ULONG_MAX   (~0UL)
 #define LLONG_MAX   ((long long)(~0ULL>>1))
 #define LLONG_MIN   (-LLONG_MAX - 1)
 #define ULLONG_MAX  (~0ULL)
 #define SIZE_MAX	(~(size_t)0)
 #define U8_MAX		((u8)~0U)
 #define S8_MAX		((s8)(U8_MAX>>1))
 #define S8_MIN		((s8)(-S8_MAX - 1))
 #define U16_MAX		((u16)~0U)
 #define S16_MAX		((s16)(U16_MAX>>1))
 #define S16_MIN		((s16)(-S16_MAX - 1))
 #define U32_MAX		((u32)~0U)
 #define S32_MAX		((s32)(U32_MAX>>1))
 #define S32_MIN		((s32)(-S32_MAX - 1))
 #define U64_MAX		((u64)~0ULL)
 #define S64_MAX		((s64)(U64_MAX>>1))
 #define S64_MIN		((s64)(-S64_MAX - 1))
+#define STACK_MAGIC	0xdeadbeef
+#define REPEAT_BYTE(x)	((~0ul / 0xff) * (x))
-#define ALIGN(x,a)      __ALIGN_MASK(x,(typeof(x))(a)-1)
+#define ALIGN(x, a)		__ALIGN_KERNEL((x), (a))
-#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
+#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)
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
 /*
  * This looks more complex than it should be. But we need to
  * get the type for the ~ right in round_down (it needs to be
  * as wide as the result!), and we want to evaluate the macro
  * arguments just once each.
  */
 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
 #define round_down(x, y) ((x) & ~__round_mask(x, y))
 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 #define DIV_ROUND_UP_ULL(ll,d) \
 	({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })
 #if BITS_PER_LONG == 32
 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
 #else
 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
 #endif
 /* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */
 #define roundup(x, y) (                                 \
 {                                                       \
         const typeof(y) __y = y;                        \
         (((x) + (__y - 1)) / __y) * __y;                \
 }                                                       \
+)
 #define rounddown(x, y) (				\
 {							\
 	typeof(x) __x = (x);				\
 	__x - (__x % (y));				\
 }							\
+)
 /*
  * Divide positive or negative dividend by positive divisor and round
  * to closest integer. Result is undefined for negative divisors and
  * for negative dividends if the divisor variable type is unsigned.
  */
 #define DIV_ROUND_CLOSEST(x, divisor)(                  \
 {                                                       \
 	typeof(x) __x = x;				\
 	typeof(divisor) __d = divisor;			\
 	(((typeof(x))-1) > 0 ||				\
 	 ((typeof(divisor))-1) > 0 || (__x) > 0) ?	\
 		(((__x) + ((__d) / 2)) / (__d)) :	\
 		(((__x) - ((__d) / 2)) / (__d));	\
 }                                                       \
+)
 /*
  * Multiplies an integer by a fraction, while avoiding unnecessary
  * overflow or loss of precision.
  */
 #define mult_frac(x, numer, denom)(			\
 {							\
 	typeof(x) quot = (x) / (denom);			\
 	typeof(x) rem  = (x) % (denom);			\
 	(quot * (numer)) + ((rem * (numer)) / (denom));	\
 }							\
+)
-#define clamp_t(type, val, min, max) ({         \
-        type __val = (val);                     \
-        type __min = (min);                     \
-        type __max = (max);                     \
-        __val = __val < __min ? __min: __val;   \
+#define _RET_IP_		(unsigned long)__builtin_return_address(0)
+#define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
+#ifdef CONFIG_LBDAF
+# include
+# define sector_div(a, b) do_div(a, b)
+#else
+# define sector_div(n, b)( \
+{ \
+	int _res; \
+	_res = (n) % (b); \
+	(n) /= (b); \
+	_res; \
-        __val > __max ? __max: __val; })
+} \
+)
 #endif
 /**
  * upper_32_bits - return bits 32-63 of a number
  * @n: the number we're accessing
+ *
  * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress
  * the "right shift count >= width of type" warning when that quantity is
  * 32-bits.
  */
 #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
 /**
  * lower_32_bits - return bits 0-31 of a number
  * @n: the number we're accessing
  */
 #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);                  \
                 (__x < 0) ? -__x : __x;         \
         })
 #define KERN_EMERG      "<0>"   /* system is unusable                   */
 #define KERN_ALERT      "<1>"   /* action must be taken immediately     */
 #define KERN_CRIT       "<2>"   /* critical conditions                  */
 #define KERN_ERR        "<3>"   /* error conditions                     */
 #define KERN_WARNING    "<4>"   /* warning conditions                   */
 #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);
 	return buf;
+}
+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 {
+enum ftrace_dump_mode {
-    DUMP_PREFIX_NONE,
+	DUMP_NONE,
-    DUMP_PREFIX_ADDRESS,
+	DUMP_ALL,
-    DUMP_PREFIX_OFFSET
+	DUMP_ORIG,
+};
+#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);
-int hex_to_bin(char ch);
+extern void tracing_start(void);
+extern void tracing_stop(void);
+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)
+/**
+ * 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.
+ */
+#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"))) =	\
-int hex2bin(u8 *dst, const char *src, size_t count);
+		__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);			\
-//int printk(const char *fmt, ...);
+} while (0)
+extern __printf(2, 3)
+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)
 #define printk(fmt, arg...)    dbgprintf(fmt , ##arg)
 	return 0;
 extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
-extern __printf(2, 3)
+static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
-char *kasprintf(gfp_t gfp, const char *fmt, ...);
+#endif /* CONFIG_TRACING */
 /*
  * min()/max()/clamp() macros that also do
  * strict type-checking.. See the
  * "unnecessary" pointer comparison.
  */
 #define min(x, y) ({                \
     typeof(x) _min1 = (x);          \
     typeof(y) _min2 = (y);          \
     (void) (&_min1 == &_min2);      \
     _min1 < _min2 ? _min1 : _min2; })
 #define max(x, y) ({                \
     typeof(x) _max1 = (x);          \
     typeof(y) _max2 = (y);          \
     (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) ({			\
-	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); })
+#define max3(x, y, z) max((typeof(x))max(x, y), z)
 /**
  * min_not_zero - return the minimum that is _not_ zero, unless both are zero
  * @x: value1
  * @y: value2
  */
 #define min_not_zero(x, y) ({			\
 	typeof(x) __x = (x);			\
 	typeof(y) __y = (y);			\
 	__x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })
 /**
  * clamp - return a value clamped to a given range with strict typechecking
  * @val: current value
- * @min: minimum allowable value
+ * @lo: lowest allowable value
- * @max: maximum 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) ({			\
+#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)
-	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; })
 /*
  * ..and if you can't take the strict
  * types, you can specify one yourself.
+ *
  * Or not use min/max/clamp at all, of course.
  */
 #define min_t(type, x, y) ({            \
     type __min1 = (x);          \
     type __min2 = (y);          \
     __min1 < __min2 ? __min1: __min2; })
 #define max_t(type, x, y) ({            \
     type __max1 = (x);          \
     type __max2 = (y);          \
     __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.
  * @member: the name of the member within the struct.
+ *
  */
 #define container_of(ptr, type, member) ({          \
     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
+/* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */
-static inline void *kcalloc(size_t n, size_t size, uint32_t flags)
+#define VERIFY_OCTAL_PERMISSIONS(perms)					\
-{
+	(BUILD_BUG_ON_ZERO((perms) < 0) +				\
+	 BUILD_BUG_ON_ZERO((perms) > 0777) +				\
+	 /* User perms >= group perms >= other perms */			\
-        if (n != 0 && size > ULONG_MAX / n)
+	 BUILD_BUG_ON_ZERO(((perms) >> 6) < (((perms) >> 3) & 7)) +	\
+	 BUILD_BUG_ON_ZERO((((perms) >> 3) & 7) < ((perms) & 7)) +	\
-                return NULL;
+	 /* Other writable?  Generally considered a bad idea. */	\
-        return kzalloc(n * size, 0);
+	 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
+{
     struct page  **pages;         /* physical memory backend */
     unsigned int   count;
     unsigned int   allocated;
     void           *vma;
 };
 struct vm_area_struct {};
 struct address_space {};
 struct device
+{
     struct device   *parent;
     void            *driver_data;
 };
 static inline void dev_set_drvdata(struct device *dev, void *data)
+{
     dev->driver_data = data;
+}
 static inline void *dev_get_drvdata(struct device *dev)
+{
     return dev->driver_data;
+}
 #define preempt_disable()       do { } while (0)
 #define preempt_enable_no_resched() do { } while (0)
 #define preempt_enable()        do { } while (0)
 #define preempt_check_resched()     do { } while (0)
 #define preempt_disable_notrace()       do { } while (0)
 #define preempt_enable_no_resched_notrace() do { } while (0)
 #define preempt_enable_notrace()        do { } while (0)
 #define in_dbg_master() (0)
 #define HZ 100
 struct tvec_base;
 struct timer_list {
          struct list_head entry;
          unsigned long expires;
          void (*function)(unsigned long);
          unsigned long data;
          u32  handle;
 };
 #define setup_timer(_timer, _fn, _data)                                 \
         do {                                                            \
                 (_timer)->function = (_fn);                             \
                 (_timer)->data = (_data);                               \
                 (_timer)->handle = 0;                                   \
         } while (0)
 int del_timer(struct timer_list *timer);
 # 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)      \
 :"m" (*(volatile type __force *)addr) barrier); return ret; }
 #define build_mmio_write(name, size, type, reg, barrier) \
 static inline void name(type val, volatile void __iomem *addr) \
 { asm volatile("mov" size " %0,%1": :reg (val), \
 "m" (*(volatile type __force *)addr) barrier); }
 build_mmio_read(readb, "b", unsigned char, "=q", :"memory")
 build_mmio_read(readw, "w", unsigned short, "=r", :"memory")
 build_mmio_read(readl, "l", unsigned int, "=r", :"memory")
 build_mmio_read(__readb, "b", unsigned char, "=q", )
 build_mmio_read(__readw, "w", unsigned short, "=r", )
 build_mmio_read(__readl, "l", unsigned int, "=r", )
 build_mmio_write(writeb, "b", unsigned char, "q", :"memory")
 build_mmio_write(writew, "w", unsigned short, "r", :"memory")
 build_mmio_write(writel, "l", unsigned int, "r", :"memory")
 build_mmio_write(__writeb, "b", unsigned char, "q", )
 build_mmio_write(__writew, "w", unsigned short, "r", )
 build_mmio_write(__writel, "l", unsigned int, "r", )
 #define readb_relaxed(a) __readb(a)
 #define readw_relaxed(a) __readw(a)
 #define readl_relaxed(a) __readl(a)
 #define __raw_readb __readb
 #define __raw_readw __readw
 #define __raw_readl __readl
 #define __raw_writeb __writeb
 #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)
 #define mmiowb() barrier()
 #define dev_err(dev, format, arg...)            \
         printk("Error %s " format, __func__ , ## arg)
 #define dev_warn(dev, format, arg...)            \
         printk("Warning %s " format, __func__ , ## arg)
 #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;
 };
 #define page_to_phys(page)    ((dma_addr_t)(page))
 struct vm_fault {
     unsigned int flags;             /* FAULT_FLAG_xxx flags */
     pgoff_t pgoff;                  /* Logical page offset based on vma */
     void __user *virtual_address;   /* Faulting virtual address */
     struct page *page;              /* ->fault handlers should return a
                                      * page here, unless VM_FAULT_NOPAGE
                                      * is set (which is also implied by
                                      * VM_FAULT_ERROR).
                                      */
 };
 struct pagelist {
     dma_addr_t    *page;
     unsigned int   nents;
 };
 #define page_cache_release(page)        FreePage(page_to_phys(page))
 #define alloc_page(gfp_mask) (struct page*)AllocPage()
 #define __free_page(page) FreePage(page_to_phys(page))
 #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))
 #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) \
+//#define RCU_INIT_POINTER(p, v) \
-        do { \
+//        do { \
-                p = (typeof(*v) __force __rcu *)(v); \
+//                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); \
-        } 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); \
-        })
 //        })
 unsigned int hweight16(unsigned int w);
 #define cpufreq_quick_get_max(x) GetCpuFreq()
 extern unsigned int tsc_khz;
 #define on_each_cpu(func,info,wait)             \
         ({                                      \
                 func(info);                     \
 ;                              \
         })
 static inline __must_check long __copy_to_user(void __user *to,
         const void *from, unsigned long n)
+{
     if (__builtin_constant_p(n)) {
         switch(n) {
         case 1:
             *(u8 __force *)to = *(u8 *)from;
             return 0;
         case 2:
             *(u16 __force *)to = *(u16 *)from;
             return 0;
         case 4:
             *(u32 __force *)to = *(u32 *)from;
             return 0;
 #ifdef CONFIG_64BIT
         case 8:
             *(u64 __force *)to = *(u64 *)from;
             return 0;
 #endif
         default:
             break;
+        }
+    }
-    memcpy((void __force *)to, from, n);
+    __builtin_memcpy((void __force *)to, from, n);
     return 0;
+}
 struct seq_file;
 void *kmap(struct page *page);
 void *kmap_atomic(struct page *page);
 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
 #endif

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/kernel.h – Rev 5178 → 5270