Subversion Repositories Kolibri OS

#ifndef _LINUX_KERNEL_H

#define _LINUX_KERNEL_H

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#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_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)

#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));	\

}							\

)

/*

 * Same as above but for u64 dividends. divisor must be a 32-bit

 * number.

 */

#define DIV_ROUND_CLOSEST_ULL(x, divisor)(		\

{							\

	typeof(divisor) __d = divisor;			\

	unsigned long long _tmp = (x) + (__d) / 2;	\

	do_div(_tmp, __d);				\

	_tmp;						\

}							\

)

/*

 * 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 _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; \

} \

)

#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))

#ifdef CONFIG_PREEMPT_VOLUNTARY

extern int _cond_resched(void);

# define might_resched() _cond_resched()

#else

# define might_resched() do { } while (0)

#endif

#ifdef CONFIG_DEBUG_ATOMIC_SLEEP

  void ___might_sleep(const char *file, int line, int preempt_offset);

  void __might_sleep(const char *file, int line, int preempt_offset);

/**

 * might_sleep - annotation for functions that can sleep

 *

 * this macro will print a stack trace if it is executed in an atomic

 * context (spinlock, irq-handler, ...).

 *

 * This is a useful debugging help to be able to catch problems early and not

 * be bitten later when the calling function happens to sleep when it is not

 * supposed to.

 */

# define might_sleep() \

	do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)

# define sched_annotate_sleep()	(current->task_state_change = 0)

#else

  static inline void ___might_sleep(const char *file, int line,

				   int preempt_offset) { }

  static inline void __might_sleep(const char *file, int line,

				   int preempt_offset) { }

# define might_sleep() do { might_resched(); } while (0)

# define sched_annotate_sleep() do { } while (0)

#endif

#define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)

/**

 * abs - return absolute value of an argument

 * @x: the value.  If it is unsigned type, it is converted to signed type first

 *   (s64, long or int depending on its size).

 *

 * Return: an absolute value of x.  If x is 64-bit, macro's return type is s64,

 *   otherwise it is signed long.

 */

#define abs(x) __builtin_choose_expr(sizeof(x) == sizeof(s64), ({	\

		s64 __x = (x);						\

		(__x < 0) ? -__x : __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;							\

	}))

/**

 * reciprocal_scale - "scale" a value into range [0, ep_ro)

 * @val: value

 * @ep_ro: right open interval endpoint

 *

 * Perform a "reciprocal multiplication" in order to "scale" a value into

 * range [0, ep_ro), where the upper interval endpoint is right-open.

 * This is useful, e.g. for accessing a index of an array containing

 * ep_ro elements, for example. Think of it as sort of modulus, only that

 * the result isn't that of modulo. ;) Note that if initial input is a

 * small value, then result will return 0.

 *

 * Return: a result based on val in interval [0, ep_ro).

 */

static inline u32 reciprocal_scale(u32 val, u32 ep_ro)

{

	return (u32)(((u64) val * ep_ro) >> 32);

}

#if defined(CONFIG_MMU) && \

	(defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP))

#define might_fault() __might_fault(__FILE__, __LINE__)

void __might_fault(const char *file, int line);

#else

static inline void might_fault(void) { }

#endif

#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 unsigned long simple_strtoul(const char *,char **,unsigned int);

extern long simple_strtol(const char *,char **,unsigned int);

extern unsigned long long simple_strtoull(const char *,char **,unsigned int);

extern long long simple_strtoll(const char *,char **,unsigned int);

extern int num_to_str(char *buf, int size, unsigned long long num);

/* lib/printf utilities */

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 __printf(2, 0)

char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);

extern __printf(2, 0)

const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);

extern __scanf(2, 3)

int sscanf(const char *, const char *, ...);

extern __scanf(2, 0)

int vsscanf(const char *, const char *, va_list);

extern int oops_in_progress;		/* If set, an oops, panic(), BUG() or die() is in progress */

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

#define TAINT_LIVEPATCH			15

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 *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.

 */

enum ftrace_dump_mode {

	DUMP_NONE,

	DUMP_ALL,

	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);

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"))) =	\

		__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)

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 __printf(2, 0) int

__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);

extern __printf(2, 0) 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 __printf(1, 0) 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.

 */

#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) min((typeof(x))min(x, y), z)

#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

 * @lo: lowest allowable value

 * @hi: highest allowable value

 *

 * 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, lo, hi) min((typeof(val))max(val, lo), hi)

/*

 * ..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? */

#define VERIFY_OCTAL_PERMISSIONS(perms)						\

	(BUILD_BUG_ON_ZERO((perms) < 0) +					\

	 BUILD_BUG_ON_ZERO((perms) > 0777) +					\

	 /* USER_READABLE >= GROUP_READABLE >= OTHER_READABLE */		\

	 BUILD_BUG_ON_ZERO((((perms) >> 6) & 4) < (((perms) >> 3) & 4)) +	\

	 BUILD_BUG_ON_ZERO((((perms) >> 3) & 4) < ((perms) & 4)) +		\

	 /* USER_WRITABLE >= GROUP_WRITABLE */					\

	 BUILD_BUG_ON_ZERO((((perms) >> 6) & 2) < (((perms) >> 3) & 2)) +	\

	 /* OTHER_WRITABLE?  Generally considered a bad idea. */		\

	 BUILD_BUG_ON_ZERO((perms) & 2) +					\

	 (perms))

void free (void *ptr);

typedef unsigned long   pgprotval_t;

struct file

{

    struct page  **pages;         /* physical memory backend */

    unsigned int   count;

    unsigned int   allocated;

    void           *vma;

};

struct vm_area_struct {};

struct address_space {};

#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)

#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

#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)

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 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 IS_ENABLED(a)  0

#define cpufreq_quick_get_max(x) GetCpuFreq()

extern unsigned int tsc_khz;

#define on_each_cpu(func,info,wait)             \

        ({                                      \

                func(info);                     \

                0;                              \

        })

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;

        }

    }

    __builtin_memcpy((void __force *)to, from, n);

    return 0;

}

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