# 1 "lib/radix-clear.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "lib/radix-clear.c"

# 1 "include/linux/errno.h" 1



# 1 "include/asm/errno.h" 1



# 1 "include/asm-generic/errno.h" 1



# 1 "include/asm-generic/errno-base.h" 1
# 5 "include/asm-generic/errno.h" 2
# 5 "include/asm/errno.h" 2
# 5 "include/linux/errno.h" 2
# 3 "lib/radix-clear.c" 2
# 1 "include/linux/init.h" 1



# 1 "include/linux/config.h" 1



# 1 "include/linux/autoconf.h" 1
# 5 "include/linux/config.h" 2
# 5 "include/linux/init.h" 2
# 1 "include/linux/compiler.h" 1
# 28 "include/linux/compiler.h"
# 1 "include/linux/compiler-gcc3.h" 1



# 1 "include/linux/compiler-gcc.h" 1
# 5 "include/linux/compiler-gcc3.h" 2
# 29 "include/linux/compiler.h" 2
# 6 "include/linux/init.h" 2
# 64 "include/linux/init.h"
typedef int (*initcall_t)(void);
typedef void (*exitcall_t)(void);

extern initcall_t __con_initcall_start, __con_initcall_end;
extern initcall_t __security_initcall_start, __security_initcall_end;


extern char saved_command_line[];
# 110 "include/linux/init.h"
struct obs_kernel_param {
        const char *str;
        int (*setup_func)(char *);
        int early;
};
# 145 "include/linux/init.h"
void __attribute__ ((__section__ (".init.text"))) parse_early_param(void);
# 4 "lib/radix-clear.c" 2
# 1 "include/linux/kernel.h" 1
# 10 "include/linux/kernel.h"
# 1 "/usr/lib64/gcc-lib/x86_64-suse-linux/3.3.3/include/stdarg.h" 1 3 4
# 43 "/usr/lib64/gcc-lib/x86_64-suse-linux/3.3.3/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 105 "/usr/lib64/gcc-lib/x86_64-suse-linux/3.3.3/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 11 "include/linux/kernel.h" 2
# 1 "include/linux/linkage.h" 1




# 1 "include/asm/linkage.h" 1
# 6 "include/linux/linkage.h" 2
# 12 "include/linux/kernel.h" 2
# 1 "include/linux/stddef.h" 1
# 13 "include/linux/kernel.h" 2
# 1 "include/linux/types.h" 1
# 13 "include/linux/types.h"
# 1 "include/linux/posix_types.h" 1
# 36 "include/linux/posix_types.h"
typedef struct {
        unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;
typedef int __kernel_mqd_t;

# 1 "include/asm/posix_types.h" 1
# 10 "include/asm/posix_types.h"
typedef unsigned long __kernel_ino_t;
typedef unsigned int __kernel_mode_t;
typedef unsigned long __kernel_nlink_t;
typedef long __kernel_off_t;
typedef int __kernel_pid_t;
typedef int __kernel_ipc_pid_t;
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
typedef unsigned long __kernel_size_t;
typedef long __kernel_ssize_t;
typedef long __kernel_ptrdiff_t;
typedef long __kernel_time_t;
typedef long __kernel_suseconds_t;
typedef long __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef int __kernel_daddr_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;


typedef long long __kernel_loff_t;


typedef struct {
        int val[2];
} __kernel_fsid_t;

typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;
typedef __kernel_uid_t __kernel_uid32_t;
typedef __kernel_gid_t __kernel_gid32_t;

typedef unsigned long __kernel_old_dev_t;




static __inline__ __attribute__((always_inline)) void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp)
{
        unsigned long _tmp = fd / (8 * sizeof(unsigned long));
        unsigned long _rem = fd % (8 * sizeof(unsigned long));
        fdsetp->fds_bits[_tmp] |= (1UL<<_rem);
}


static __inline__ __attribute__((always_inline)) void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp)
{
        unsigned long _tmp = fd / (8 * sizeof(unsigned long));
        unsigned long _rem = fd % (8 * sizeof(unsigned long));
        fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem);
}


static __inline__ __attribute__((always_inline)) int __FD_ISSET(unsigned long fd, __const__ __kernel_fd_set *p)
{
        unsigned long _tmp = fd / (8 * sizeof(unsigned long));
        unsigned long _rem = fd % (8 * sizeof(unsigned long));
        return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0;
}






static __inline__ __attribute__((always_inline)) void __FD_ZERO(__kernel_fd_set *p)
{
        unsigned long *tmp = p->fds_bits;
        int i;

        if (__builtin_constant_p((1024/(8 * sizeof(unsigned long))))) {
                switch ((1024/(8 * sizeof(unsigned long)))) {
                        case 32:
                          tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                          tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
                          tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0;
                          tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0;
                          tmp[16] = 0; tmp[17] = 0; tmp[18] = 0; tmp[19] = 0;
                          tmp[20] = 0; tmp[21] = 0; tmp[22] = 0; tmp[23] = 0;
                          tmp[24] = 0; tmp[25] = 0; tmp[26] = 0; tmp[27] = 0;
                          tmp[28] = 0; tmp[29] = 0; tmp[30] = 0; tmp[31] = 0;
                          return;
                        case 16:
                          tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                          tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
                          tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0;
                          tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0;
                          return;
                        case 8:
                          tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                          tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
                          return;
                        case 4:
                          tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                          return;
                }
        }
        i = (1024/(8 * sizeof(unsigned long)));
        while (i) {
                i--;
                *tmp = 0;
                tmp++;
        }
}
# 48 "include/linux/posix_types.h" 2
# 14 "include/linux/types.h" 2
# 1 "include/asm/types.h" 1





typedef unsigned short umode_t;






typedef __signed__ char __s8;
typedef unsigned char __u8;

typedef __signed__ short __s16;
typedef unsigned short __u16;

typedef __signed__ int __s32;
typedef unsigned int __u32;

typedef __signed__ long long __s64;
typedef unsigned long long __u64;
# 36 "include/asm/types.h"
typedef signed char s8;
typedef unsigned char u8;

typedef signed short s16;
typedef unsigned short u16;

typedef signed int s32;
typedef unsigned int u32;

typedef signed long long s64;
typedef unsigned long long u64;

typedef u64 dma64_addr_t;
typedef u64 dma_addr_t;

typedef u64 sector_t;


typedef unsigned short kmem_bufctl_t;
# 15 "include/linux/types.h" 2



typedef __u32 __kernel_dev_t;

typedef __kernel_fd_set fd_set;
typedef __kernel_dev_t dev_t;
typedef __kernel_ino_t ino_t;
typedef __kernel_mode_t mode_t;
typedef __kernel_nlink_t nlink_t;
typedef __kernel_off_t off_t;
typedef __kernel_pid_t pid_t;
typedef __kernel_daddr_t daddr_t;
typedef __kernel_key_t key_t;
typedef __kernel_suseconds_t suseconds_t;
typedef __kernel_timer_t timer_t;
typedef __kernel_clockid_t clockid_t;
typedef __kernel_mqd_t mqd_t;


typedef __kernel_uid32_t uid_t;
typedef __kernel_gid32_t gid_t;
typedef __kernel_uid16_t uid16_t;
typedef __kernel_gid16_t gid16_t;



typedef __kernel_old_uid_t old_uid_t;
typedef __kernel_old_gid_t old_gid_t;
# 55 "include/linux/types.h"
typedef __kernel_loff_t loff_t;
# 64 "include/linux/types.h"
typedef __kernel_size_t size_t;




typedef __kernel_ssize_t ssize_t;




typedef __kernel_ptrdiff_t ptrdiff_t;




typedef __kernel_time_t time_t;




typedef __kernel_clock_t clock_t;




typedef __kernel_caddr_t caddr_t;



typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;


typedef unsigned char unchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;




typedef __u8 u_int8_t;
typedef __s8 int8_t;
typedef __u16 u_int16_t;
typedef __s16 int16_t;
typedef __u32 u_int32_t;
typedef __s32 int32_t;



typedef __u8 uint8_t;
typedef __u16 uint16_t;
typedef __u32 uint32_t;


typedef __u64 uint64_t;
typedef __u64 u_int64_t;
typedef __s64 int64_t;
# 149 "include/linux/types.h"
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
# 163 "include/linux/types.h"
struct ustat {
        __kernel_daddr_t f_tfree;
        __kernel_ino_t f_tinode;
        char f_fname[6];
        char f_fpack[6];
};
# 14 "include/linux/kernel.h" 2

# 1 "include/linux/bitops.h" 1



# 1 "include/asm/bitops.h" 1
# 28 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) void set_bit(int nr, volatile void * addr)
{
        __asm__ __volatile__( "lock ; "
                "btsl %1,%0"
                :"=m" ((*(volatile long *) addr))
                :"dIr" (nr) : "memory");
}
# 45 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) void __set_bit(int nr, volatile void * addr)
{
        __asm__ volatile(
                "btsl %1,%0"
                :"=m" ((*(volatile long *) addr))
                :"dIr" (nr) : "memory");
}
# 63 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) void clear_bit(int nr, volatile void * addr)
{
        __asm__ __volatile__( "lock ; "
                "btrl %1,%0"
                :"=m" ((*(volatile long *) addr))
                :"dIr" (nr));
}

static __inline__ __attribute__((always_inline)) void __clear_bit(int nr, volatile void * addr)
{
        __asm__ __volatile__(
                "btrl %1,%0"
                :"=m" ((*(volatile long *) addr))
                :"dIr" (nr));
}
# 91 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) void __change_bit(int nr, volatile void * addr)
{
        __asm__ __volatile__(
                "btcl %1,%0"
                :"=m" ((*(volatile long *) addr))
                :"dIr" (nr));
}
# 108 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) void change_bit(int nr, volatile void * addr)
{
        __asm__ __volatile__( "lock ; "
                "btcl %1,%0"
                :"=m" ((*(volatile long *) addr))
                :"dIr" (nr));
}
# 124 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int test_and_set_bit(int nr, volatile void * addr)
{
        int oldbit;

        __asm__ __volatile__( "lock ; "
                "btsl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit),"=m" ((*(volatile long *) addr))
                :"dIr" (nr) : "memory");
        return oldbit;
}
# 144 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile void * addr)
{
        int oldbit;

        __asm__(
                "btsl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit),"=m" ((*(volatile long *) addr))
                :"dIr" (nr));
        return oldbit;
}
# 163 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile void * addr)
{
        int oldbit;

        __asm__ __volatile__( "lock ; "
                "btrl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit),"=m" ((*(volatile long *) addr))
                :"dIr" (nr) : "memory");
        return oldbit;
}
# 183 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile void * addr)
{
        int oldbit;

        __asm__(
                "btrl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit),"=m" ((*(volatile long *) addr))
                :"dIr" (nr));
        return oldbit;
}


static __inline__ __attribute__((always_inline)) int __test_and_change_bit(int nr, volatile void * addr)
{
        int oldbit;

        __asm__ __volatile__(
                "btcl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit),"=m" ((*(volatile long *) addr))
                :"dIr" (nr) : "memory");
        return oldbit;
}
# 214 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int test_and_change_bit(int nr, volatile void * addr)
{
        int oldbit;

        __asm__ __volatile__( "lock ; "
                "btcl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit),"=m" ((*(volatile long *) addr))
                :"dIr" (nr) : "memory");
        return oldbit;
}
# 234 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int constant_test_bit(int nr, const volatile void * addr)
{
        return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
}

static __inline__ __attribute__((always_inline)) int variable_test_bit(int nr, volatile const void * addr)
{
        int oldbit;

        __asm__ __volatile__(
                "btl %2,%1\n\tsbbl %0,%0"
                :"=r" (oldbit)
                :"m" ((*(volatile long *) addr)),"dIr" (nr));
        return oldbit;
}
# 257 "include/asm/bitops.h"
extern long find_first_zero_bit(const unsigned long * addr, unsigned long size);
extern long find_next_zero_bit (const unsigned long * addr, long size, long offset);
extern long find_first_bit(const unsigned long * addr, unsigned long size);
extern long find_next_bit(const unsigned long * addr, long size, long offset);


static inline __attribute__((always_inline)) unsigned long __scanbit(unsigned long val, unsigned long max)
{
        asm("bsfq %1,%0 ; cmovz %2,%0" : "=&r" (val) : "r" (val), "r" (max));
        return val;
}
# 292 "include/asm/bitops.h"
extern unsigned long
find_next_zero_string(unsigned long *bitmap, long start, long nbits, int len);

static inline __attribute__((always_inline)) void set_bit_string(unsigned long *bitmap, unsigned long i,
                                  int len)
{
        unsigned long end = i + len;
        while (i < end) {
                __set_bit(i, bitmap);
                i++;
        }
}

static inline __attribute__((always_inline)) void __clear_bit_string(unsigned long *bitmap, unsigned long i,
                                    int len)
{
        unsigned long end = i + len;
        while (i < end) {
                __clear_bit(i, bitmap);
                i++;
        }
}







static __inline__ __attribute__((always_inline)) unsigned long ffz(unsigned long word)
{
        __asm__("bsfq %1,%0"
                :"=r" (word)
                :"r" (~word));
        return word;
}







static __inline__ __attribute__((always_inline)) unsigned long __ffs(unsigned long word)
{
        __asm__("bsfq %1,%0"
                :"=r" (word)
                :"rm" (word));
        return word;
}



static inline __attribute__((always_inline)) int sched_find_first_bit(const unsigned long *b)
{
        if (b[0])
                return __ffs(b[0]);
        if (b[1])
                return __ffs(b[1]) + 64;
        if (b[2])
                return __ffs(b[2]) + 128;
}
# 363 "include/asm/bitops.h"
static __inline__ __attribute__((always_inline)) int ffs(int x)
{
        int r;

        __asm__("bsfl %1,%0\n\t"
                "cmovzl %2,%0"
                : "=r" (r) : "rm" (x), "r" (-1));
        return r+1;
}
# 5 "include/linux/bitops.h" 2







static inline __attribute__((always_inline)) int generic_ffs(int x)
{
        int r = 1;

        if (!x)
                return 0;
        if (!(x & 0xffff)) {
                x >>= 16;
                r += 16;
        }
        if (!(x & 0xff)) {
                x >>= 8;
                r += 8;
        }
        if (!(x & 0xf)) {
                x >>= 4;
                r += 4;
        }
        if (!(x & 3)) {
                x >>= 2;
                r += 2;
        }
        if (!(x & 1)) {
                x >>= 1;
                r += 1;
        }
        return r;
}





extern __inline__ __attribute__((always_inline)) int generic_fls(int x)
{
        int r = 32;

        if (!x)
                return 0;
        if (!(x & 0xffff0000u)) {
                x <<= 16;
                r -= 16;
        }
        if (!(x & 0xff000000u)) {
                x <<= 8;
                r -= 8;
        }
        if (!(x & 0xf0000000u)) {
                x <<= 4;
                r -= 4;
        }
        if (!(x & 0xc0000000u)) {
                x <<= 2;
                r -= 2;
        }
        if (!(x & 0x80000000u)) {
                x <<= 1;
                r -= 1;
        }
        return r;
}

extern __inline__ __attribute__((always_inline)) int get_bitmask_order(unsigned int count)
{
        int order;

        order = generic_fls(count);
        return order;
}






static inline __attribute__((always_inline)) unsigned int generic_hweight32(unsigned int w)
{
        unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
        res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
        res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
        return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
}

static inline __attribute__((always_inline)) unsigned int generic_hweight16(unsigned int w)
{
        unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555);
        res = (res & 0x3333) + ((res >> 2) & 0x3333);
        res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
        return (res & 0x00FF) + ((res >> 8) & 0x00FF);
}

static inline __attribute__((always_inline)) unsigned int generic_hweight8(unsigned int w)
{
        unsigned int res = (w & 0x55) + ((w >> 1) & 0x55);
        res = (res & 0x33) + ((res >> 2) & 0x33);
        return (res & 0x0F) + ((res >> 4) & 0x0F);
}

static inline __attribute__((always_inline)) unsigned long generic_hweight64(__u64 w)
{




        u64 res;
        res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
        res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
        res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
        res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
        res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
        return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);

}

static inline __attribute__((always_inline)) unsigned long hweight_long(unsigned long w)
{
        return sizeof(w) == 4 ? generic_hweight32(w) : generic_hweight64(w);
}
# 16 "include/linux/kernel.h" 2
# 1 "include/asm/byteorder.h" 1
# 9 "include/asm/byteorder.h"
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 ___arch__swab64(__u64 x)
{
        __asm__("bswapq %0" : "=r" (x) : "0" (x));
        return x;
}

static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swab32(__u32 x)
{
        __asm__("bswapl %0" : "=r" (x) : "0" (x));
        return x;
}
# 31 "include/asm/byteorder.h"
# 1 "include/linux/byteorder/little_endian.h" 1
# 12 "include/linux/byteorder/little_endian.h"
# 1 "include/linux/byteorder/swab.h" 1
# 133 "include/linux/byteorder/swab.h"
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 x)
{
        return ({ __u16 __tmp = (x) ; ({ __u16 __x = (__tmp); ((__u16)( (((__u16)(__x) & (__u16)0x00ffU) << 8) | (((__u16)(__x) & (__u16)0xff00U) >> 8) )); }); });
}
static __inline__ __attribute__((always_inline)) __u16 __swab16p(const __u16 *x)
{
        return ({ __u16 __tmp = (*(x)) ; ({ __u16 __x = (__tmp); ((__u16)( (((__u16)(__x) & (__u16)0x00ffU) << 8) | (((__u16)(__x) & (__u16)0xff00U) >> 8) )); }); });
}
static __inline__ __attribute__((always_inline)) void __swab16s(__u16 *addr)
{
        do { *(addr) = ({ __u16 __tmp = (*((addr))) ; ({ __u16 __x = (__tmp); ((__u16)( (((__u16)(__x) & (__u16)0x00ffU) << 8) | (((__u16)(__x) & (__u16)0xff00U) >> 8) )); }); }); } while (0);
}

static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswab32(__u32 x)
{
        return ___arch__swab32(x);
}
static __inline__ __attribute__((always_inline)) __u32 __swab32p(const __u32 *x)
{
        return ___arch__swab32(*(x));
}
static __inline__ __attribute__((always_inline)) void __swab32s(__u32 *addr)
{
        do { *(addr) = ___arch__swab32(*((addr))); } while (0);
}


static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 __fswab64(__u64 x)
{





        return ___arch__swab64(x);

}
static __inline__ __attribute__((always_inline)) __u64 __swab64p(const __u64 *x)
{
        return ___arch__swab64(*(x));
}
static __inline__ __attribute__((always_inline)) void __swab64s(__u64 *addr)
{
        do { *(addr) = ___arch__swab64(*((addr))); } while (0);
}
# 13 "include/linux/byteorder/little_endian.h" 2
# 43 "include/linux/byteorder/little_endian.h"
static inline __attribute__((always_inline)) __le64 __cpu_to_le64p(const __u64 *p)
{
        return ( __le64)*p;
}
static inline __attribute__((always_inline)) __u64 __le64_to_cpup(const __le64 *p)
{
        return ( __u64)*p;
}
static inline __attribute__((always_inline)) __le32 __cpu_to_le32p(const __u32 *p)
{
        return ( __le32)*p;
}
static inline __attribute__((always_inline)) __u32 __le32_to_cpup(const __le32 *p)
{
        return ( __u32)*p;
}
static inline __attribute__((always_inline)) __le16 __cpu_to_le16p(const __u16 *p)
{
        return ( __le16)*p;
}
static inline __attribute__((always_inline)) __u16 __le16_to_cpup(const __le16 *p)
{
        return ( __u16)*p;
}
static inline __attribute__((always_inline)) __be64 __cpu_to_be64p(const __u64 *p)
{
        return ( __be64)__swab64p(p);
}
static inline __attribute__((always_inline)) __u64 __be64_to_cpup(const __be64 *p)
{
        return __swab64p((__u64 *)p);
}
static inline __attribute__((always_inline)) __be32 __cpu_to_be32p(const __u32 *p)
{
        return ( __be32)__swab32p(p);
}
static inline __attribute__((always_inline)) __u32 __be32_to_cpup(const __be32 *p)
{
        return __swab32p((__u32 *)p);
}
static inline __attribute__((always_inline)) __be16 __cpu_to_be16p(const __u16 *p)
{
        return ( __be16)__swab16p(p);
}
static inline __attribute__((always_inline)) __u16 __be16_to_cpup(const __be16 *p)
{
        return __swab16p((__u16 *)p);
}
# 104 "include/linux/byteorder/little_endian.h"
# 1 "include/linux/byteorder/generic.h" 1
# 150 "include/linux/byteorder/generic.h"
extern __u32 ntohl(__be32);
extern __be32 htonl(__u32);
extern __u16 ntohs(__be16);
extern __be16 htons(__u16);
# 105 "include/linux/byteorder/little_endian.h" 2
# 32 "include/asm/byteorder.h" 2
# 17 "include/linux/kernel.h" 2
# 1 "include/asm/bug.h" 1



# 1 "include/linux/stringify.h" 1
# 5 "include/asm/bug.h" 2





struct bug_frame {
       unsigned char ud2[2];


        char *filename;
        unsigned short line;
} __attribute__((packed));





void out_of_line_bug(void);
# 1 "include/asm-generic/bug.h" 1
# 24 "include/asm/bug.h" 2
# 18 "include/linux/kernel.h" 2
# 40 "include/linux/kernel.h"
extern int console_printk[];






struct completion;
# 68 "include/linux/kernel.h"
extern struct notifier_block *panic_notifier_list;
 void panic(const char * fmt, ...)
        __attribute__ ((noreturn, format (printf, 1, 2)));
 void do_exit(long error_code)
        __attribute__((noreturn));
 void complete_and_exit(struct completion *, long)
        __attribute__((noreturn));
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 sprintf(char * buf, const char * fmt, ...)
        __attribute__ ((format (printf, 2, 3)));
extern int vsprintf(char *buf, const char *, va_list);
extern int snprintf(char * buf, size_t size, const char * fmt, ...)
        __attribute__ ((format (printf, 3, 4)));
extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
        __attribute__ ((format (printf, 3, 4)));
extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);

extern int sscanf(const char *, const char *, ...)
        __attribute__ ((format (scanf,2,3)));
extern int vsscanf(const char *, const char *, va_list);

extern int get_option(char **str, int *pint);
extern char *get_options(const char *str, int nints, int *ints);
extern unsigned long long memparse(char *ptr, char **retptr);

extern int __kernel_text_address(unsigned long addr);
extern int kernel_text_address(unsigned long addr);
extern int session_of_pgrp(int pgrp);

 int vprintk(const char *fmt, va_list args);
 int printk(const char * fmt, ...)
        __attribute__ ((format (printf, 1, 2)));

unsigned long int_sqrt(unsigned long);

static inline __attribute__((always_inline)) int __attribute__((pure)) long_log2(unsigned long x)
{
        int r = 0;
        for (x >>= 1; x > 0; x >>= 1)
                r++;
        return r;
}

static inline __attribute__((always_inline)) unsigned long __attribute__((__const__)) roundup_pow_of_two(unsigned long x)
{
        return (1UL << generic_fls(x - 1));
}

extern int printk_ratelimit(void);
extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);

static inline __attribute__((always_inline)) void console_silent(void)
{
        (console_printk[0]) = 0;
}

static inline __attribute__((always_inline)) void console_verbose(void)
{
        if ((console_printk[0]))
                (console_printk[0]) = 15;
}

extern void bust_spinlocks(int yes);
extern int oops_in_progress;
extern int panic_on_oops;
extern int tainted;
extern const char *print_tainted(void);


extern enum system_states {
        SYSTEM_BOOTING,
        SYSTEM_RUNNING,
        SYSTEM_HALT,
        SYSTEM_POWER_OFF,
        SYSTEM_RESTART,
} system_state;






extern void dump_stack(void);
# 254 "include/linux/kernel.h"
struct sysinfo {
        long uptime;
        unsigned long loads[3];
        unsigned long totalram;
        unsigned long freeram;
        unsigned long sharedram;
        unsigned long bufferram;
        unsigned long totalswap;
        unsigned long freeswap;
        unsigned short procs;
        unsigned short pad;
        unsigned long totalhigh;
        unsigned long freehigh;
        unsigned int mem_unit;
        char _f[20-2*sizeof(long)-sizeof(int)];
};

extern void BUILD_BUG(void);
# 5 "lib/radix-clear.c" 2
# 1 "include/linux/module.h" 1
# 10 "include/linux/module.h"
# 1 "include/linux/sched.h" 1



# 1 "include/asm/param.h" 1
# 5 "include/linux/sched.h" 2


# 1 "include/linux/capability.h" 1
# 32 "include/linux/capability.h"
typedef struct __user_cap_header_struct {
        __u32 version;
        int pid;
} *cap_user_header_t;

typedef struct __user_cap_data_struct {
        __u32 effective;
        __u32 permitted;
        __u32 inheritable;
} *cap_user_data_t;



# 1 "include/linux/spinlock.h" 1
# 9 "include/linux/spinlock.h"
# 1 "include/linux/preempt.h" 1
# 10 "include/linux/spinlock.h" 2


# 1 "include/linux/thread_info.h" 1
# 13 "include/linux/thread_info.h"
struct restart_block {
        long (*fn)(struct restart_block *);
        unsigned long arg0, arg1, arg2, arg3;
};

extern long do_no_restart_syscall(struct restart_block *parm);


# 1 "include/asm/thread_info.h" 1
# 12 "include/asm/thread_info.h"
# 1 "include/asm/page.h" 1
# 35 "include/asm/page.h"
void clear_page(void *);
void copy_page(void *, void *);







typedef struct { unsigned long pte; } pte_t;
typedef struct { unsigned long pmd; } pmd_t;
typedef struct { unsigned long pgd; } pgd_t;
typedef struct { unsigned long pml4; } pml4_t;


typedef struct { unsigned long pgprot; } pgprot_t;
# 64 "include/asm/page.h"
extern unsigned long vm_stack_flags, vm_stack_flags32;
extern unsigned long vm_data_default_flags, vm_data_default_flags32;
extern unsigned long vm_force_exec32;
# 95 "include/asm/page.h"
extern __inline__ __attribute__((always_inline)) int get_order(unsigned long size)
{
        int order;

        size = (size-1) >> (12 -1);
        order = -1;
        do {
                size >>= 1;
                order++;
        } while (size);
        return order;
}
# 148 "include/asm/page.h"
struct task_struct;
struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
int in_gate_area(struct task_struct *task, unsigned long addr);
# 13 "include/asm/thread_info.h" 2

# 1 "include/asm/pda.h" 1






# 1 "include/linux/cache.h" 1





# 1 "include/asm/cache.h" 1
# 7 "include/linux/cache.h" 2
# 8 "include/asm/pda.h" 2


struct x8664_pda {
        struct task_struct *pcurrent;
        unsigned long data_offset;
        struct x8664_pda *me;
        unsigned long kernelstack;
        unsigned long oldrsp;
        unsigned long irqrsp;
        int irqcount;
        int cpunumber;
        char *irqstackptr;
        unsigned long volatile *level4_pgt;
        unsigned int __softirq_pending;
        unsigned int __nmi_count;
        struct mm_struct *active_mm;
        int mmu_state;
        unsigned apic_timer_irqs;
} __attribute__((__aligned__((1 << (7)))));





extern struct x8664_pda cpu_pda[];
# 41 "include/asm/pda.h"
extern void __bad_pda_field(void);
# 15 "include/asm/thread_info.h" 2







struct task_struct;
struct exec_domain;
# 1 "include/asm/mmsegment.h" 1



typedef struct {
        unsigned long seg;
} mm_segment_t;
# 25 "include/asm/thread_info.h" 2

struct thread_info {
        struct task_struct *task;
        struct exec_domain *exec_domain;
        __u32 flags;
        __u32 status;
        __u32 cpu;
        int preempt_count;

        mm_segment_t addr_limit;
        struct restart_block restart_block;
};
# 60 "include/asm/thread_info.h"
static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
{
        struct thread_info *ti;
        ti = (void *)(({ typedef typeof(((struct x8664_pda *)0)->kernelstack) T__; T__ ret__; switch ((sizeof(((struct x8664_pda *)0)->kernelstack))) { case 2: asm volatile("mov" "w %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->kernelstack)):"memory"); break;case 4: asm volatile("mov" "l %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->kernelstack)):"memory"); break;case 8: asm volatile("mov" "q %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->kernelstack)):"memory"); break; default: __bad_pda_field(); } ret__; }) + (5*8) - (1UL << (12 + 1)));
        return ti;
}


static inline __attribute__((always_inline)) struct thread_info *stack_thread_info(void)
{
        struct thread_info *ti;
        __asm__("andq %%rsp,%0; ":"=r" (ti) : "0" (~((1UL << (12 + 1)) - 1)));
        return ti;
}
# 22 "include/linux/thread_info.h" 2
# 30 "include/linux/thread_info.h"
static inline __attribute__((always_inline)) void set_thread_flag(int flag)
{
        set_bit(flag,&current_thread_info()->flags);
}

static inline __attribute__((always_inline)) void clear_thread_flag(int flag)
{
        clear_bit(flag,&current_thread_info()->flags);
}

static inline __attribute__((always_inline)) int test_and_set_thread_flag(int flag)
{
        return test_and_set_bit(flag,&current_thread_info()->flags);
}

static inline __attribute__((always_inline)) int test_and_clear_thread_flag(int flag)
{
        return test_and_clear_bit(flag,&current_thread_info()->flags);
}

static inline __attribute__((always_inline)) int test_thread_flag(int flag)
{
        return (__builtin_constant_p(flag) ? constant_test_bit((flag),(&current_thread_info()->flags)) : variable_test_bit((flag),(&current_thread_info()->flags)));
}

static inline __attribute__((always_inline)) void set_ti_thread_flag(struct thread_info *ti, int flag)
{
        set_bit(flag,&ti->flags);
}

static inline __attribute__((always_inline)) void clear_ti_thread_flag(struct thread_info *ti, int flag)
{
        clear_bit(flag,&ti->flags);
}

static inline __attribute__((always_inline)) int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
{
        return test_and_set_bit(flag,&ti->flags);
}

static inline __attribute__((always_inline)) int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
{
        return test_and_clear_bit(flag,&ti->flags);
}

static inline __attribute__((always_inline)) int test_ti_thread_flag(struct thread_info *ti, int flag)
{
        return (__builtin_constant_p(flag) ? constant_test_bit((flag),(&ti->flags)) : variable_test_bit((flag),(&ti->flags)));
}

static inline __attribute__((always_inline)) void set_need_resched(void)
{
        set_thread_flag(3);
}

static inline __attribute__((always_inline)) void clear_need_resched(void)
{
        clear_thread_flag(3);
}
# 13 "include/linux/spinlock.h" 2



# 1 "include/asm/processor.h" 1
# 10 "include/asm/processor.h"
# 1 "include/asm/segment.h" 1
# 11 "include/asm/processor.h" 2


# 1 "include/asm/sigcontext.h" 1
# 10 "include/asm/sigcontext.h"
struct _fpstate {
        __u16 cwd;
        __u16 swd;
        __u16 twd;
        __u16 fop;
        __u64 rip;
        __u64 rdp;
        __u32 mxcsr;
        __u32 mxcsr_mask;
        __u32 st_space[32];
        __u32 xmm_space[64];
        __u32 reserved2[24];
};

struct sigcontext {
        unsigned long r8;
        unsigned long r9;
        unsigned long r10;
        unsigned long r11;
        unsigned long r12;
        unsigned long r13;
        unsigned long r14;
        unsigned long r15;
        unsigned long rdi;
        unsigned long rsi;
        unsigned long rbp;
        unsigned long rbx;
        unsigned long rdx;
        unsigned long rax;
        unsigned long rcx;
        unsigned long rsp;
        unsigned long rip;
        unsigned long eflags;
        unsigned short cs;
        unsigned short gs;
        unsigned short fs;
        unsigned short __pad0;
        unsigned long err;
        unsigned long trapno;
        unsigned long oldmask;
        unsigned long cr2;
        struct _fpstate *fpstate;
        unsigned long reserved1[8];
};
# 14 "include/asm/processor.h" 2
# 1 "include/asm/cpufeature.h" 1
# 15 "include/asm/processor.h" 2

# 1 "include/linux/threads.h" 1
# 17 "include/asm/processor.h" 2
# 1 "include/asm/msr.h" 1
# 70 "include/asm/msr.h"
extern inline __attribute__((always_inline)) void cpuid(int op, int *eax, int *ebx, int *ecx, int *edx)
{
        __asm__("cpuid"
                : "=a" (*eax),
                  "=b" (*ebx),
                  "=c" (*ecx),
                  "=d" (*edx)
                : "0" (op));
}




extern inline __attribute__((always_inline)) unsigned int cpuid_eax(unsigned int op)
{
        unsigned int eax;

        __asm__("cpuid"
                : "=a" (eax)
                : "0" (op)
                : "bx", "cx", "dx");
        return eax;
}
extern inline __attribute__((always_inline)) unsigned int cpuid_ebx(unsigned int op)
{
        unsigned int eax, ebx;

        __asm__("cpuid"
                : "=a" (eax), "=b" (ebx)
                : "0" (op)
                : "cx", "dx" );
        return ebx;
}
extern inline __attribute__((always_inline)) unsigned int cpuid_ecx(unsigned int op)
{
        unsigned int eax, ecx;

        __asm__("cpuid"
                : "=a" (eax), "=c" (ecx)
                : "0" (op)
                : "bx", "dx" );
        return ecx;
}
extern inline __attribute__((always_inline)) unsigned int cpuid_edx(unsigned int op)
{
        unsigned int eax, edx;

        __asm__("cpuid"
                : "=a" (eax), "=d" (edx)
                : "0" (op)
                : "bx", "cx");
        return edx;
}
# 18 "include/asm/processor.h" 2
# 1 "include/asm/current.h" 1




struct task_struct;



static inline __attribute__((always_inline)) struct task_struct *get_current(void)
{
        struct task_struct *t = ({ typedef typeof(((struct x8664_pda *)0)->pcurrent) T__; T__ ret__; switch ((sizeof(((struct x8664_pda *)0)->pcurrent))) { case 2: asm volatile("mov" "w %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->pcurrent)):"memory"); break;case 4: asm volatile("mov" "l %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->pcurrent)):"memory"); break;case 8: asm volatile("mov" "q %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->pcurrent)):"memory"); break; default: __bad_pda_field(); } ret__; });
        return t;
}
# 19 "include/asm/processor.h" 2
# 1 "include/asm/system.h" 1
# 51 "include/asm/system.h"
extern void load_gs_index(unsigned);
# 80 "include/asm/system.h"
struct alt_instr {
        __u8 *instr;
        __u8 *replacement;
        __u8 cpuid;
        __u8 instrlen;
        __u8 replacementlen;
        __u8 pad[5];
};
# 145 "include/asm/system.h"
static inline __attribute__((always_inline)) unsigned long read_cr0(void)
{
        unsigned long cr0;
        asm volatile("movq %%cr0,%0" : "=r" (cr0));
        return cr0;
}

static inline __attribute__((always_inline)) void write_cr0(unsigned long val)
{
        asm volatile("movq %0,%%cr0" :: "r" (val));
}

static inline __attribute__((always_inline)) unsigned long read_cr3(void)
{
        unsigned long cr3;
        asm("movq %%cr3,%0" : "=r" (cr3));
        return cr3;
}

static inline __attribute__((always_inline)) unsigned long read_cr4(void)
{
        unsigned long cr4;
        asm("movq %%cr4,%0" : "=r" (cr4));
        return cr4;
}

static inline __attribute__((always_inline)) void write_cr4(unsigned long val)
{
        asm volatile("movq %0,%%cr4" :: "r" (val));
}
# 191 "include/asm/system.h"
extern inline __attribute__((always_inline)) void set_64bit(volatile unsigned long *ptr, unsigned long val)
{
        *ptr = val;
}
# 203 "include/asm/system.h"
static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
{
        switch (size) {
                case 1:
                        __asm__ __volatile__("xchgb %b0,%1"
                                :"=q" (x)
                                :"m" (*((volatile long *)(ptr))), "0" (x)
                                :"memory");
                        break;
                case 2:
                        __asm__ __volatile__("xchgw %w0,%1"
                                :"=r" (x)
                                :"m" (*((volatile long *)(ptr))), "0" (x)
                                :"memory");
                        break;
                case 4:
                        __asm__ __volatile__("xchgl %k0,%1"
                                :"=r" (x)
                                :"m" (*((volatile long *)(ptr))), "0" (x)
                                :"memory");
                        break;
                case 8:
                        __asm__ __volatile__("xchgq %0,%1"
                                :"=r" (x)
                                :"m" (*((volatile long *)(ptr))), "0" (x)
                                :"memory");
                        break;
        }
        return x;
}
# 242 "include/asm/system.h"
static inline __attribute__((always_inline)) unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
                                      unsigned long new, int size)
{
        unsigned long prev;
        switch (size) {
        case 1:
                __asm__ __volatile__("lock ; " "cmpxchgb %b1,%2"
                                     : "=a"(prev)
                                     : "q"(new), "m"(*((volatile long *)(ptr))), "0"(old)
                                     : "memory");
                return prev;
        case 2:
                __asm__ __volatile__("lock ; " "cmpxchgw %w1,%2"
                                     : "=a"(prev)
                                     : "q"(new), "m"(*((volatile long *)(ptr))), "0"(old)
                                     : "memory");
                return prev;
        case 4:
                __asm__ __volatile__("lock ; " "cmpxchgl %k1,%2"
                                     : "=a"(prev)
                                     : "q"(new), "m"(*((volatile long *)(ptr))), "0"(old)
                                     : "memory");
                return prev;
        case 8:
                __asm__ __volatile__("lock ; " "cmpxchgq %1,%2"
                                     : "=a"(prev)
                                     : "q"(new), "m"(*((volatile long *)(ptr))), "0"(old)
                                     : "memory");
                return prev;
        }
        return old;
}
# 333 "include/asm/system.h"
void disable_hlt(void);
void enable_hlt(void);


void eat_key(void);
# 20 "include/asm/processor.h" 2

# 1 "include/asm/percpu.h" 1
# 35 "include/asm/percpu.h"
extern void setup_per_cpu_areas(void);
# 22 "include/asm/processor.h" 2
# 1 "include/linux/personality.h" 1







struct exec_domain;
struct pt_regs;

extern int register_exec_domain(struct exec_domain *);
extern int unregister_exec_domain(struct exec_domain *);
extern int __set_personality(unsigned long);






enum {
        MMAP_PAGE_ZERO = 0x0100000,
        ADDR_COMPAT_LAYOUT = 0x0200000,
        READ_IMPLIES_EXEC = 0x0400000,
        ADDR_LIMIT_32BIT = 0x0800000,
        SHORT_INODE = 0x1000000,
        WHOLE_SECONDS = 0x2000000,
        STICKY_TIMEOUTS = 0x4000000,
        ADDR_LIMIT_3GB = 0x8000000,
};
# 43 "include/linux/personality.h"
enum {
        PER_LINUX = 0x0000,
        PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT,
        PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
        PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
        PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS |
                                         WHOLE_SECONDS | SHORT_INODE,
        PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
        PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
        PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS,
        PER_BSD = 0x0006,
        PER_SUNOS = 0x0006 | STICKY_TIMEOUTS,
        PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
        PER_LINUX32 = 0x0008,
        PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB,
        PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,
        PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,
        PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,
        PER_RISCOS = 0x000c,
        PER_SOLARIS = 0x000d | STICKY_TIMEOUTS,
        PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
        PER_OSF4 = 0x000f,
        PER_HPUX = 0x0010,
        PER_MASK = 0x00ff,
};
# 76 "include/linux/personality.h"
typedef void (*handler_t)(int, struct pt_regs *);

struct exec_domain {
        const char *name;
        handler_t handler;
        unsigned char pers_low;
        unsigned char pers_high;
        unsigned long *signal_map;
        unsigned long *signal_invmap;
        struct map_segment *err_map;
        struct map_segment *socktype_map;
        struct map_segment *sockopt_map;
        struct map_segment *af_map;
        struct module *module;
        struct exec_domain *next;
};
# 23 "include/asm/processor.h" 2
# 50 "include/asm/processor.h"
struct cpuinfo_x86 {
        __u8 x86;
        __u8 x86_vendor;
        __u8 x86_model;
        __u8 x86_mask;
        int cpuid_level;
        __u32 x86_capability[6];
        char x86_vendor_id[16];
        char x86_model_id[64];
        int x86_cache_size;
        int x86_clflush_size;
        int x86_cache_alignment;
        int x86_tlbsize;
        __u8 x86_virt_bits, x86_phys_bits;
        __u8 x86_num_cores;
        __u8 x86_apicid;
        __u32 x86_power;
        unsigned long loops_per_jiffy;
} __attribute__((__aligned__((1 << (7)))));
# 82 "include/asm/processor.h"
extern struct cpuinfo_x86 cpu_data[];






extern char ignore_irq13;

extern void identify_cpu(struct cpuinfo_x86 *);
extern void print_cpu_info(struct cpuinfo_x86 *);
extern void dodgy_tsc(void);
# 137 "include/asm/processor.h"
extern unsigned long mmu_cr4_features;

static inline __attribute__((always_inline)) void set_in_cr4 (unsigned long mask)
{
        mmu_cr4_features |= mask;
        __asm__("movq %%cr4,%%rax\n\t"
                "orq %0,%%rax\n\t"
                "movq %%rax,%%cr4\n"
                : : "irg" (mask)
                :"ax");
}

static inline __attribute__((always_inline)) void clear_in_cr4 (unsigned long mask)
{
        mmu_cr4_features &= ~mask;
        __asm__("movq %%cr4,%%rax\n\t"
                "andq %0,%%rax\n\t"
                "movq %%rax,%%cr4\n"
                : : "irg" (~mask)
                :"ax");
}
# 189 "include/asm/processor.h"
struct i387_fxsave_struct {
        u16 cwd;
        u16 swd;
        u16 twd;
        u16 fop;
        u64 rip;
        u64 rdp;
        u32 mxcsr;
        u32 mxcsr_mask;
        u32 st_space[32];
        u32 xmm_space[64];
        u32 padding[24];
} __attribute__ ((aligned (16)));

union i387_union {
        struct i387_fxsave_struct fxsave;
};

struct tss_struct {
        u32 reserved1;
        u64 rsp0;
        u64 rsp1;
        u64 rsp2;
        u64 reserved2;
        u64 ist[7];
        u32 reserved3;
        u32 reserved4;
        u16 reserved5;
        u16 io_bitmap_base;
# 227 "include/asm/processor.h"
        unsigned long io_bitmap[((65536/8)/sizeof(long)) + 1];
} __attribute__((packed)) __attribute__((__aligned__((1 << (7)))));

extern struct cpuinfo_x86 boot_cpu_data;
extern __typeof__(struct tss_struct) per_cpu__init_tss;



struct thread_struct {
        unsigned long rsp0;
        unsigned long rsp;
        unsigned long userrsp;
        unsigned long fs;
        unsigned long gs;
        unsigned short es, ds, fsindex, gsindex;

        unsigned long debugreg0;
        unsigned long debugreg1;
        unsigned long debugreg2;
        unsigned long debugreg3;
        unsigned long debugreg6;
        unsigned long debugreg7;

        unsigned long cr2, trap_no, error_code;

        union i387_union i387 __attribute__((aligned(16)));


        int ioperm;
        unsigned long *io_bitmap_ptr;
        unsigned io_bitmap_max;

        u64 tls_array[3];
} __attribute__((aligned(16)));
# 288 "include/asm/processor.h"
struct task_struct;
struct mm_struct;


extern void release_thread(struct task_struct *);


extern void prepare_to_copy(struct task_struct *tsk);




extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);







extern unsigned long get_wchan(struct task_struct *p);





struct microcode_header {
        unsigned int hdrver;
        unsigned int rev;
        unsigned int date;
        unsigned int sig;
        unsigned int cksum;
        unsigned int ldrver;
        unsigned int pf;
        unsigned int datasize;
        unsigned int totalsize;
        unsigned int reserved[3];
};

struct microcode {
        struct microcode_header hdr;
        unsigned int bits[0];
};

typedef struct microcode microcode_t;
typedef struct microcode_header microcode_header_t;


struct extended_signature {
        unsigned int sig;
        unsigned int pf;
        unsigned int cksum;
};

struct extended_sigtable {
        unsigned int count;
        unsigned int cksum;
        unsigned int reserved[3];
        struct extended_signature sigs[0];
};
# 375 "include/asm/processor.h"
extern inline __attribute__((always_inline)) void rep_nop(void)
{
        __asm__ __volatile__("rep;nop": : :"memory");
}


extern inline __attribute__((always_inline)) void sync_core(void)
{
        int tmp;
        asm volatile("cpuid" : "=a" (tmp) : "0" (1) : "ebx","ecx","edx","memory");
}




static inline __attribute__((always_inline)) void prefetch(void *x)
{
        asm volatile("prefetcht0 %0" :: "m" (*(unsigned long *)x));
}


static inline __attribute__((always_inline)) void prefetchw(void *x)
{
        asm volatile ("661:\n\t" ".byte 0x66,0x66,0x90\n" ".byte 0x66,0x90\n" "\n662:\n" ".section .altinstructions,\"a\"\n" "  .align 8\n" "  .quad 661b\n" "  .quad 663f\n" "  .byte %c0\n" "  .byte 662b-661b\n" "  .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" "prefetchw (%1)" "\n664:\n" ".previous" :: "i" ((1*32+31)), "r" (x));



}
# 437 "include/asm/processor.h"
static inline __attribute__((always_inline)) void __monitor(const void *eax, unsigned long ecx,
                unsigned long edx)
{

        asm volatile(
                ".byte 0x0f,0x01,0xc8;"
                : :"a" (eax), "c" (ecx), "d"(edx));
}

static inline __attribute__((always_inline)) void __mwait(unsigned long eax, unsigned long ecx)
{

        asm volatile(
                ".byte 0x0f,0x01,0xc9;"
                : :"a" (eax), "c" (ecx));
}
# 17 "include/linux/spinlock.h" 2
# 39 "include/linux/spinlock.h"
# 1 "include/asm/spinlock.h" 1



# 1 "include/asm/atomic.h" 1
# 24 "include/asm/atomic.h"
typedef struct { volatile int counter; } atomic_t;
# 52 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) void atomic_add(int i, atomic_t *v)
{
        __asm__ __volatile__(
                "lock ; " "addl %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}
# 67 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) void atomic_sub(int i, atomic_t *v)
{
        __asm__ __volatile__(
                "lock ; " "subl %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}
# 84 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic_sub_and_test(int i, atomic_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "subl %2,%0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"ir" (i), "m" (v->counter) : "memory");
        return c;
}







static __inline__ __attribute__((always_inline)) void atomic_inc(atomic_t *v)
{
        __asm__ __volatile__(
                "lock ; " "incl %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}







static __inline__ __attribute__((always_inline)) void atomic_dec(atomic_t *v)
{
        __asm__ __volatile__(
                "lock ; " "decl %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}
# 131 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic_dec_and_test(atomic_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "decl %0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"m" (v->counter) : "memory");
        return c != 0;
}
# 150 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic_inc_and_test(atomic_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "incl %0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"m" (v->counter) : "memory");
        return c != 0;
}
# 170 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic_add_negative(int i, atomic_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "addl %2,%0; sets %1"
                :"=m" (v->counter), "=qm" (c)
                :"ir" (i), "m" (v->counter) : "memory");
        return c;
}



typedef struct { volatile long counter; } atomic64_t;
# 212 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) void atomic64_add(long i, atomic64_t *v)
{
        __asm__ __volatile__(
                "lock ; " "addq %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}
# 227 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) void atomic64_sub(long i, atomic64_t *v)
{
        __asm__ __volatile__(
                "lock ; " "subq %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}
# 244 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic64_sub_and_test(long i, atomic64_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "subq %2,%0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"ir" (i), "m" (v->counter) : "memory");
        return c;
}







static __inline__ __attribute__((always_inline)) void atomic64_inc(atomic64_t *v)
{
        __asm__ __volatile__(
                "lock ; " "incq %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}







static __inline__ __attribute__((always_inline)) void atomic64_dec(atomic64_t *v)
{
        __asm__ __volatile__(
                "lock ; " "decq %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}
# 291 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic64_dec_and_test(atomic64_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "decq %0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"m" (v->counter) : "memory");
        return c != 0;
}
# 310 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) int atomic64_inc_and_test(atomic64_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "incq %0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"m" (v->counter) : "memory");
        return c != 0;
}
# 330 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) long atomic64_add_negative(long i, atomic64_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                "lock ; " "addq %2,%0; sets %1"
                :"=m" (v->counter), "=qm" (c)
                :"ir" (i), "m" (v->counter) : "memory");
        return c;
}
# 5 "include/asm/spinlock.h" 2
# 1 "include/asm/rwlock.h" 1
# 6 "include/asm/spinlock.h" 2



extern int printk(const char * fmt, ...)
        __attribute__ ((format (printf, 1, 2)));





typedef struct {
        volatile unsigned int lock;



} spinlock_t;
# 71 "include/asm/spinlock.h"
static inline __attribute__((always_inline)) void _raw_spin_unlock(spinlock_t *lock)
{




        __asm__ __volatile__(
                "movb $1,%0" :"=m" (lock->lock) : : "memory"
        );
}
# 103 "include/asm/spinlock.h"
static inline __attribute__((always_inline)) int _raw_spin_trylock(spinlock_t *lock)
{
        char oldval;
        __asm__ __volatile__(
                "xchgb %b0,%1"
                :"=q" (oldval), "=m" (lock->lock)
                :"0" (0) : "memory");
        return oldval > 0;
}

static inline __attribute__((always_inline)) void _raw_spin_lock(spinlock_t *lock)
{






        __asm__ __volatile__(
                "\n1:\t" "lock ; decb %0\n\t" "js 2f\n" ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t" "2:\t" "rep;nop\n\t" "cmpb $0,%0\n\t" "jle 2b\n\t" "jmp 1b\n" ".previous\n\t"
                :"=m" (lock->lock) : : "memory");
}
# 137 "include/asm/spinlock.h"
typedef struct {
        volatile unsigned int lock;



} rwlock_t;
# 169 "include/asm/spinlock.h"
static inline __attribute__((always_inline)) void _raw_read_lock(rwlock_t *rw)
{



        do { if (__builtin_constant_p(rw)) asm volatile("lock ; " "subl $1,%0\n\t" "js 2f\n" "1:\n" ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t" "2:\tpushq %%rax\n\t" "leaq %0,%%rax\n\t" "call " "__read_lock_failed" "\n\t" "popq %%rax\n\t" "jmp 1b\n" ".previous\n\t" :"=m" (*((volatile int *)rw))::"memory"); else asm volatile("lock ; " "subl $1,(%0)\n\t" "js 2f\n" "1:\n" ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t" "2:\tcall " "__read_lock_failed" "\n\t" "jmp 1b\n" ".previous\n\t" ::"a" (rw) : "memory"); } while (0);
}

static inline __attribute__((always_inline)) void _raw_write_lock(rwlock_t *rw)
{



        do { if (__builtin_constant_p(rw)) asm volatile("lock ; " "subl $" "0x01000000" ",(%0)\n\t" "jnz 2f\n" "1:\n" ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t" "2:\tpushq %%rax\n\t" "leaq %0,%%rax\n\t" "call " "__write_lock_failed" "\n\t" "popq %%rax\n\t" "jmp 1b\n" ".previous\n\t" :"=m" (*((volatile long *)rw))::"memory"); else asm volatile("lock ; " "subl $" "0x01000000" ",(%0)\n\t" "jnz 2f\n" "1:\n" ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t" "2:\tcall " "__write_lock_failed" "\n\t" "jmp 1b\n" ".previous\n\t" ::"a" (rw) : "memory"); } while (0);
}




static inline __attribute__((always_inline)) int _raw_write_trylock(rwlock_t *lock)
{
        atomic_t *count = (atomic_t *)lock;
        if (atomic_sub_and_test(0x01000000, count))
                return 1;
        atomic_add(0x01000000, count);
        return 0;
}
# 40 "include/linux/spinlock.h" 2



int __attribute__((section(".spinlock.text"))) _spin_trylock(spinlock_t *lock);
int __attribute__((section(".spinlock.text"))) _write_trylock(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_lock(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _write_lock(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_lock(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _read_lock(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_unlock(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _write_unlock(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _read_unlock(rwlock_t *lock);
unsigned long __attribute__((section(".spinlock.text"))) _spin_lock_irqsave(spinlock_t *lock);
unsigned long __attribute__((section(".spinlock.text"))) _read_lock_irqsave(rwlock_t *lock);
unsigned long __attribute__((section(".spinlock.text"))) _write_lock_irqsave(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_lock_irq(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_lock_bh(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _read_lock_irq(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _read_lock_bh(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _write_lock_irq(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _write_lock_bh(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);
void __attribute__((section(".spinlock.text"))) _spin_unlock_irq(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _spin_unlock_bh(spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags);
void __attribute__((section(".spinlock.text"))) _read_unlock_irq(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _read_unlock_bh(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags);
void __attribute__((section(".spinlock.text"))) _write_unlock_irq(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _write_unlock_bh(rwlock_t *lock);
int __attribute__((section(".spinlock.text"))) _spin_trylock_bh(spinlock_t *lock);
int in_lock_functions(unsigned long addr);
# 461 "include/linux/spinlock.h"
extern int atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
# 470 "include/linux/spinlock.h"
static inline __attribute__((always_inline)) void bit_spin_lock(int bitnum, unsigned long *addr)
{







        do { } while (0);

        while (test_and_set_bit(bitnum, addr)) {
                while ((__builtin_constant_p(bitnum) ? constant_test_bit((bitnum),(addr)) : variable_test_bit((bitnum),(addr))))
                        rep_nop();
        }

}




static inline __attribute__((always_inline)) int bit_spin_trylock(int bitnum, unsigned long *addr)
{

        int ret;

        do { } while (0);
        ret = !test_and_set_bit(bitnum, addr);
        if (!ret)
                do { } while (0);
        return ret;




}




static inline __attribute__((always_inline)) void bit_spin_unlock(int bitnum, unsigned long *addr)
{

        do { if (__builtin_expect(!!((!(__builtin_constant_p(bitnum) ? constant_test_bit((bitnum),(addr)) : variable_test_bit((bitnum),(addr))))!=0), 0)) asm volatile("ud2 ; .quad %c1 ; .short %c0" :: "i"(513), "i" ("radix_clear")); } while(0);
        __asm__ __volatile__("": : :"memory");
        clear_bit(bitnum, addr);

        do { } while (0);
}




static inline __attribute__((always_inline)) int bit_spin_is_locked(int bitnum, unsigned long *addr)
{

        return (__builtin_constant_p(bitnum) ? constant_test_bit((bitnum),(addr)) : variable_test_bit((bitnum),(addr)));





}
# 46 "include/linux/capability.h" 2

extern spinlock_t task_capability_lock;
# 59 "include/linux/capability.h"
typedef __u32 kernel_cap_t;
# 291 "include/linux/capability.h"
extern kernel_cap_t cap_bset;
# 319 "include/linux/capability.h"
static inline __attribute__((always_inline)) kernel_cap_t cap_combine(kernel_cap_t a, kernel_cap_t b)
{
     kernel_cap_t dest;
     (dest) = (a) | (b);
     return dest;
}

static inline __attribute__((always_inline)) kernel_cap_t cap_intersect(kernel_cap_t a, kernel_cap_t b)
{
     kernel_cap_t dest;
     (dest) = (a) & (b);
     return dest;
}

static inline __attribute__((always_inline)) kernel_cap_t cap_drop(kernel_cap_t a, kernel_cap_t drop)
{
     kernel_cap_t dest;
     (dest) = (a) & ~(drop);
     return dest;
}

static inline __attribute__((always_inline)) kernel_cap_t cap_invert(kernel_cap_t c)
{
     kernel_cap_t dest;
     (dest) = ~(c);
     return dest;
}
# 8 "include/linux/sched.h" 2



# 1 "include/linux/timex.h" 1
# 157 "include/linux/timex.h"
# 1 "include/asm/timex.h" 1
# 10 "include/asm/timex.h"
# 1 "include/asm/8253pit.h" 1
# 11 "include/asm/timex.h" 2

# 1 "include/asm/vsyscall.h" 1



# 1 "include/linux/seqlock.h" 1
# 33 "include/linux/seqlock.h"
typedef struct {
        unsigned sequence;
        spinlock_t lock;
} seqlock_t;
# 50 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) void write_seqlock(seqlock_t *sl)
{
        _spin_lock(&sl->lock);
        ++sl->sequence;
        asm volatile("sfence" ::: "memory");
}

static inline __attribute__((always_inline)) void write_sequnlock(seqlock_t *sl)
{
        asm volatile("sfence" ::: "memory");
        sl->sequence++;
        _spin_unlock(&sl->lock);
}

static inline __attribute__((always_inline)) int write_tryseqlock(seqlock_t *sl)
{
        int ret = _spin_trylock(&sl->lock);

        if (ret) {
                ++sl->sequence;
                asm volatile("sfence" ::: "memory");
        }
        return ret;
}


static inline __attribute__((always_inline)) unsigned read_seqbegin(const seqlock_t *sl)
{
        unsigned ret = sl->sequence;
        asm volatile("lfence":::"memory");
        return ret;
}
# 91 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) int read_seqretry(const seqlock_t *sl, unsigned iv)
{
        asm volatile("lfence":::"memory");
        return (iv & 1) | (sl->sequence ^ iv);
}
# 105 "include/linux/seqlock.h"
typedef struct seqcount {
        unsigned sequence;
} seqcount_t;





static inline __attribute__((always_inline)) unsigned read_seqcount_begin(const seqcount_t *s)
{
        unsigned ret = s->sequence;
        asm volatile("lfence":::"memory");
        return ret;
}






static inline __attribute__((always_inline)) int read_seqcount_retry(const seqcount_t *s, unsigned iv)
{
        asm volatile("lfence":::"memory");
        return (iv & 1) | (s->sequence ^ iv);
}






static inline __attribute__((always_inline)) void write_seqcount_begin(seqcount_t *s)
{
        s->sequence++;
        asm volatile("sfence" ::: "memory");
}

static inline __attribute__((always_inline)) void write_seqcount_end(seqcount_t *s)
{
        asm volatile("sfence" ::: "memory");
        s->sequence++;
}
# 5 "include/asm/vsyscall.h" 2

enum vsyscall_num {
        __NR_vgettimeofday,
        __NR_vtime,
};
# 29 "include/asm/vsyscall.h"
struct vxtime_data {
        long hpet_address;
        unsigned long hz;
        int last;
        unsigned long last_tsc;
        long quot;
        long tsc_quot;
        int mode;
};





extern struct vxtime_data __vxtime;
extern struct timespec __xtime;
extern volatile unsigned long __jiffies;
extern unsigned long __wall_jiffies;
extern struct timezone __sys_tz;
extern seqlock_t __xtime_lock;


extern struct vxtime_data vxtime;
extern unsigned long wall_jiffies;
extern struct timezone sys_tz;
extern int sysctl_vsyscall;
extern seqlock_t xtime_lock;
# 13 "include/asm/timex.h" 2
# 1 "include/asm/hpet.h" 1
# 44 "include/asm/hpet.h"
extern int is_hpet_enabled(void);
extern int hpet_rtc_timer_init(void);


extern int hpet_mask_rtc_irq_bit(unsigned long bit_mask);
extern int hpet_set_rtc_irq_bit(unsigned long bit_mask);
extern int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec);
extern int hpet_set_periodic_freq(unsigned long freq);
extern int hpet_rtc_dropped_irq(void);
extern int hpet_rtc_timer_init(void);
# 14 "include/asm/timex.h" 2







typedef unsigned long long cycles_t;

extern cycles_t cacheflush_time;

static inline __attribute__((always_inline)) cycles_t get_cycles (void)
{
        unsigned long long ret;

        do { unsigned int __a,__d; asm volatile("rdtsc" : "=a" (__a), "=d" (__d)); (ret) = ((unsigned long)__a) | (((unsigned long)__d)<<32); } while(0);
        return ret;
}

extern unsigned int cpu_khz;

extern struct vxtime_data vxtime;
# 158 "include/linux/timex.h" 2
# 188 "include/linux/timex.h"
# 1 "include/linux/time.h" 1
# 9 "include/linux/time.h"
struct timespec {
        time_t tv_sec;
        long tv_nsec;
};


struct timeval {
        time_t tv_sec;
        suseconds_t tv_usec;
};

struct timezone {
        int tz_minuteswest;
        int tz_dsttime;
};





# 1 "include/linux/timex.h" 1
# 30 "include/linux/time.h" 2
# 1 "include/asm/div64.h" 1
# 1 "include/asm-generic/div64.h" 1
# 2 "include/asm/div64.h" 2
# 31 "include/linux/time.h" 2
# 187 "include/linux/time.h"
static inline __attribute__((always_inline)) unsigned int jiffies_to_msecs(const unsigned long j)
{

        return (1000 / 1000) * j;





}

static inline __attribute__((always_inline)) unsigned int jiffies_to_usecs(const unsigned long j)
{

        return (1000000 / 1000) * j;





}

static inline __attribute__((always_inline)) unsigned long msecs_to_jiffies(const unsigned int m)
{
        if (m > jiffies_to_msecs(((~0UL >> 1)-1)))
                return ((~0UL >> 1)-1);

        return (m + (1000 / 1000) - 1) / (1000 / 1000);





}
# 233 "include/linux/time.h"
static __inline__ __attribute__((always_inline)) unsigned long
timespec_to_jiffies(const struct timespec *value)
{
        unsigned long sec = value->tv_sec;
        long nsec = value->tv_nsec + (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) - 1;

        if (sec >= (( (((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) / (1000000000L)) << 1) + ((((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) % (1000000000L)) << 1) + (1000000000L) / 2) / (1000000000L)) - 1)){
                sec = (( (((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) / (1000000000L)) << 1) + ((((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) % (1000000000L)) << 1) + (1000000000L) / 2) / (1000000000L)) - 1);
                nsec = 0;
        }
        return (((u64)sec * ((unsigned long)((((u64)(1000000000L) << (32 - 10)) + (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))))))) +
                (((u64)nsec * ((unsigned long)((((u64)1 << ((32 - 10) + 29)) + (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))))))) >>
                 (((32 - 10) + 29) - (32 - 10)))) >> (32 - 10);

}

static __inline__ __attribute__((always_inline)) void
jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
{




        u64 nsec = (u64)jiffies * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))));
        value->tv_sec = ({ u64 result = nsec; *&value->tv_nsec = ({ uint32_t __base = ((1000000000L)); uint32_t __rem; __rem = ((uint64_t)(result)) % __base; (result) = ((uint64_t)(result)) / __base; __rem; }); result; });
}
# 272 "include/linux/time.h"
static __inline__ __attribute__((always_inline)) unsigned long
timeval_to_jiffies(const struct timeval *value)
{
        unsigned long sec = value->tv_sec;
        long usec = value->tv_usec;

        if (sec >= (( (((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) / (1000000000L)) << 1) + ((((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) % (1000000000L)) << 1) + (1000000000L) / 2) / (1000000000L)) - 1)){
                sec = (( (((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) / (1000000000L)) << 1) + ((((((~0UL >> 1)-1) >> (32 - 10)) * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) % (1000000000L)) << 1) + (1000000000L) / 2) / (1000000000L)) - 1);
                usec = 0;
        }
        return (((u64)sec * ((unsigned long)((((u64)(1000000000L) << (32 - 10)) + (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))))))) +
                (((u64)usec * ((unsigned long)((((u64)(1000L) << ((32 - 10) + 19)) + (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))))))) + (u64)(((u64)1 << ((32 - 10) + 19)) - 1)) >>
                 (((32 - 10) + 19) - (32 - 10)))) >> (32 - 10);
}

static __inline__ __attribute__((always_inline)) void
jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
{




        u64 nsec = (u64)jiffies * (( ((1000000UL * 1000 / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))) << 8) + (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000))) / 2) / (( ((1193182UL / ((1193182UL + 1000/2) / 1000)) << 8) + (((1193182UL % ((1193182UL + 1000/2) / 1000)) << 8) + ((1193182UL + 1000/2) / 1000) / 2) / ((1193182UL + 1000/2) / 1000)))));
        value->tv_sec = ({ u64 result = nsec; *&value->tv_usec = ({ uint32_t __base = ((1000000000L)); uint32_t __rem; __rem = ((uint64_t)(result)) % __base; (result) = ((uint64_t)(result)) / __base; __rem; }); result; });
        value->tv_usec /= (1000L);
}

static __inline__ __attribute__((always_inline)) int timespec_equal(struct timespec *a, struct timespec *b)
{
        return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
}
# 319 "include/linux/time.h"
static inline __attribute__((always_inline)) unsigned long
mktime (unsigned int year, unsigned int mon,
        unsigned int day, unsigned int hour,
        unsigned int min, unsigned int sec)
{
        if (0 >= (int) (mon -= 2)) {
                mon += 12;
                year -= 1;
        }

        return (((
                (unsigned long) (year/4 - year/100 + year/400 + 367*mon/12 + day) +
                        year*365 - 719499
            )*24 + hour
          )*60 + min
        )*60 + sec;
}

extern struct timespec xtime;
extern struct timespec wall_to_monotonic;
extern seqlock_t xtime_lock;

static inline __attribute__((always_inline)) unsigned long get_seconds(void)
{
        return xtime.tv_sec;
}

struct timespec current_kernel_time(void);
# 355 "include/linux/time.h"
extern void do_gettimeofday(struct timeval *tv);
extern int do_settimeofday(struct timespec *tv);
extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
extern void clock_was_set(void);
extern int do_posix_clock_monotonic_gettime(struct timespec *tp);
extern long do_nanosleep(struct timespec *t);
extern long do_utimes(char * filename, struct timeval * times);
struct itimerval;
extern int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue);
extern int do_getitimer(int which, struct itimerval *value);
extern void getnstimeofday (struct timespec *tv);

static inline __attribute__((always_inline)) void
set_normalized_timespec (struct timespec *ts, time_t sec, long nsec)
{
        while (nsec > (1000000000L)) {
                nsec -= (1000000000L);
                ++sec;
        }
        while (nsec < 0) {
                nsec += (1000000000L);
                --sec;
        }
        ts->tv_sec = sec;
        ts->tv_nsec = nsec;
}
# 397 "include/linux/time.h"
struct itimerspec {
        struct timespec it_interval;
        struct timespec it_value;
};

struct itimerval {
        struct timeval it_interval;
        struct timeval it_value;
};
# 189 "include/linux/timex.h" 2




struct timex {
        unsigned int modes;
        long offset;
        long freq;
        long maxerror;
        long esterror;
        int status;
        long constant;
        long precision;
        long tolerance;


        struct timeval time;
        long tick;

        long ppsfreq;
        long jitter;
        int shift;
        long stabil;
        long jitcnt;
        long calcnt;
        long errcnt;
        long stbcnt;

        int :32; int :32; int :32; int :32;
        int :32; int :32; int :32; int :32;
        int :32; int :32; int :32; int :32;
};
# 285 "include/linux/timex.h"
extern unsigned long tick_usec;
extern unsigned long tick_nsec;
extern int tickadj;




extern int time_state;
extern int time_status;
extern long time_offset;
extern long time_constant;
extern long time_tolerance;
extern long time_precision;
extern long time_maxerror;
extern long time_esterror;

extern long time_phase;
extern long time_freq;
extern long time_adj;
extern long time_reftime;

extern long time_adjust;
extern long time_next_adjust;


extern long pps_offset;
extern long pps_jitter;
extern long pps_freq;
extern long pps_stabil;
extern long pps_valid;


extern int pps_shift;
extern long pps_jitcnt;
extern long pps_calcnt;
extern long pps_errcnt;
extern long pps_stbcnt;
# 374 "include/linux/timex.h"
static inline __attribute__((always_inline)) void
time_interpolator_reset(void)
{
}
# 12 "include/linux/sched.h" 2
# 1 "include/linux/jiffies.h" 1
# 16 "include/linux/jiffies.h"
extern u64 jiffies_64;
extern unsigned long volatile jiffies;




static inline __attribute__((always_inline)) u64 get_jiffies_64(void)
{
        return (u64)jiffies;
}
# 13 "include/linux/sched.h" 2
# 1 "include/linux/rbtree.h" 1
# 100 "include/linux/rbtree.h"
struct rb_node
{
        struct rb_node *rb_parent;
        int rb_color;


        struct rb_node *rb_right;
        struct rb_node *rb_left;
};

struct rb_root
{
        struct rb_node *rb_node;
};





extern void rb_insert_color(struct rb_node *, struct rb_root *);
extern void rb_erase(struct rb_node *, struct rb_root *);


extern struct rb_node *rb_next(struct rb_node *);
extern struct rb_node *rb_prev(struct rb_node *);
extern struct rb_node *rb_first(struct rb_root *);
extern struct rb_node *rb_last(struct rb_root *);


extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
                            struct rb_root *root);

static inline __attribute__((always_inline)) void rb_link_node(struct rb_node * node, struct rb_node * parent,
                                struct rb_node ** rb_link)
{
        node->rb_parent = parent;
        node->rb_color = 0;
        node->rb_left = node->rb_right = ((void *)0);

        *rb_link = node;
}
# 14 "include/linux/sched.h" 2

# 1 "include/linux/cpumask.h" 1
# 78 "include/linux/cpumask.h"
# 1 "include/linux/bitmap.h" 1







# 1 "include/linux/string.h" 1
# 16 "include/linux/string.h"
extern char * strpbrk(const char *,const char *);
extern char * strsep(char **,const char *);
extern __kernel_size_t strspn(const char *,const char *);
extern __kernel_size_t strcspn(const char *,const char *);




# 1 "include/asm/string.h" 1
# 9 "include/asm/string.h"
static inline __attribute__((always_inline)) void * __inline_memcpy(void * to, const void * from, size_t n)
{
unsigned long d0, d1, d2;
__asm__ __volatile__(
        "rep ; movsl\n\t"
        "testb $2,%b4\n\t"
        "je 1f\n\t"
        "movsw\n"
        "1:\ttestb $1,%b4\n\t"
        "je 2f\n\t"
        "movsb\n"
        "2:"
        : "=&c" (d0), "=&D" (d1), "=&S" (d2)
        :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
        : "memory");
return (to);
}





extern void *__memcpy(void *to, const void *from, size_t len);
# 46 "include/asm/string.h"
void * memmove(void * dest,const void *src,size_t count);



int __builtin_memcmp(const void * cs,const void * ct,size_t count);



size_t __builtin_strlen(const char * s);


char * __builtin_strcpy(char * dest,const char *src);


char * __builtin_strcat(char * dest, const char * src);


int __builtin_strcmp(const char * cs,const char * ct);
# 25 "include/linux/string.h" 2


extern char * __builtin_strcpy(char *,const char *);


extern char * strncpy(char *,const char *, __kernel_size_t);


size_t strlcpy(char *, const char *, size_t);


extern char * __builtin_strcat(char *, const char *);


extern char * strncat(char *, const char *, __kernel_size_t);


extern size_t strlcat(char *, const char *, __kernel_size_t);


extern int __builtin_strcmp(const char *,const char *);


extern int strncmp(const char *,const char *,__kernel_size_t);


extern int strnicmp(const char *, const char *, __kernel_size_t);


extern char * strchr(const char *,int);


extern char * strnchr(const char *, size_t, int);


extern char * strrchr(const char *,int);


extern char * strstr(const char *,const char *);


extern __kernel_size_t __builtin_strlen(const char *);


extern __kernel_size_t strnlen(const char *,__kernel_size_t);
# 82 "include/linux/string.h"
extern void * memscan(void *,int,__kernel_size_t);


extern int __builtin_memcmp(const void *,const void *,__kernel_size_t);


extern void * memchr(const void *,int,__kernel_size_t);
# 9 "include/linux/bitmap.h" 2
# 73 "include/linux/bitmap.h"
extern int __bitmap_empty(const unsigned long *bitmap, int bits);
extern int __bitmap_full(const unsigned long *bitmap, int bits);
extern int __bitmap_equal(const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
                        int bits);
extern void __bitmap_shift_right(unsigned long *dst,
                        const unsigned long *src, int shift, int bits);
extern void __bitmap_shift_left(unsigned long *dst,
                        const unsigned long *src, int shift, int bits);
extern void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern int __bitmap_intersects(const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern int __bitmap_subset(const unsigned long *bitmap1,
                        const unsigned long *bitmap2, int bits);
extern int __bitmap_weight(const unsigned long *bitmap, int bits);

extern int bitmap_scnprintf(char *buf, unsigned int len,
                        const unsigned long *src, int nbits);
extern int bitmap_parse(const char *ubuf, unsigned int ulen,
                        unsigned long *dst, int nbits);
extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);







static inline __attribute__((always_inline)) void bitmap_zero(unsigned long *dst, int nbits)
{
        if (nbits <= 64)
                *dst = 0UL;
        else {
                int len = (((nbits)+64 -1)/64) * sizeof(unsigned long);
                __builtin_memset(dst, 0, len);
        }
}

static inline __attribute__((always_inline)) void bitmap_fill(unsigned long *dst, int nbits)
{
        size_t nlongs = (((nbits)+64 -1)/64);
        if (nlongs > 1) {
                int len = (nlongs - 1) * sizeof(unsigned long);
                __builtin_memset(dst, 0xff, len);
        }
        dst[nlongs - 1] = ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL );
}

static inline __attribute__((always_inline)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
                        int nbits)
{
        if (nbits <= 64)
                *dst = *src;
        else {
                int len = (((nbits)+64 -1)/64) * sizeof(unsigned long);
                ({ size_t __len = (len); void *__ret; if (__builtin_constant_p(len) && __len >= 64) __ret = __memcpy((dst),(src),__len); else __ret = __builtin_memcpy((dst),(src),__len); __ret; });
        }
}

static inline __attribute__((always_inline)) void bitmap_and(unsigned long *dst, const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                *dst = *src1 & *src2;
        else
                __bitmap_and(dst, src1, src2, nbits);
}

static inline __attribute__((always_inline)) void bitmap_or(unsigned long *dst, const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                *dst = *src1 | *src2;
        else
                __bitmap_or(dst, src1, src2, nbits);
}

static inline __attribute__((always_inline)) void bitmap_xor(unsigned long *dst, const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                *dst = *src1 ^ *src2;
        else
                __bitmap_xor(dst, src1, src2, nbits);
}

static inline __attribute__((always_inline)) void bitmap_andnot(unsigned long *dst, const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                *dst = *src1 & ~(*src2);
        else
                __bitmap_andnot(dst, src1, src2, nbits);
}

static inline __attribute__((always_inline)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
                        int nbits)
{
        if (nbits <= 64)
                *dst = ~(*src) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL );
        else
                __bitmap_complement(dst, src, nbits);
}

static inline __attribute__((always_inline)) int bitmap_equal(const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                return ! ((*src1 ^ *src2) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
        else
                return __bitmap_equal(src1, src2, nbits);
}

static inline __attribute__((always_inline)) int bitmap_intersects(const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                return ((*src1 & *src2) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL )) != 0;
        else
                return __bitmap_intersects(src1, src2, nbits);
}

static inline __attribute__((always_inline)) int bitmap_subset(const unsigned long *src1,
                        const unsigned long *src2, int nbits)
{
        if (nbits <= 64)
                return ! ((*src1 & ~(*src2)) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
        else
                return __bitmap_subset(src1, src2, nbits);
}

static inline __attribute__((always_inline)) int bitmap_empty(const unsigned long *src, int nbits)
{
        if (nbits <= 64)
                return ! (*src & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
        else
                return __bitmap_empty(src, nbits);
}

static inline __attribute__((always_inline)) int bitmap_full(const unsigned long *src, int nbits)
{
        if (nbits <= 64)
                return ! (~(*src) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
        else
                return __bitmap_full(src, nbits);
}

static inline __attribute__((always_inline)) int bitmap_weight(const unsigned long *src, int nbits)
{
        return __bitmap_weight(src, nbits);
}

static inline __attribute__((always_inline)) void bitmap_shift_right(unsigned long *dst,
                        const unsigned long *src, int n, int nbits)
{
        if (nbits <= 64)
                *dst = *src >> n;
        else
                __bitmap_shift_right(dst, src, n, nbits);
}

static inline __attribute__((always_inline)) void bitmap_shift_left(unsigned long *dst,
                        const unsigned long *src, int n, int nbits)
{
        if (nbits <= 64)
                *dst = (*src << n) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL );
        else
                __bitmap_shift_left(dst, src, n, nbits);
}
# 79 "include/linux/cpumask.h" 2


typedef struct { unsigned long bits[(((8)+64 -1)/64)]; } cpumask_t;
extern cpumask_t _unused_cpumask_arg_;


static inline __attribute__((always_inline)) void __cpu_set(int cpu, volatile cpumask_t *dstp)
{
        set_bit(cpu, dstp->bits);
}


static inline __attribute__((always_inline)) void __cpu_clear(int cpu, volatile cpumask_t *dstp)
{
        clear_bit(cpu, dstp->bits);
}


static inline __attribute__((always_inline)) void __cpus_setall(cpumask_t *dstp, int nbits)
{
        bitmap_fill(dstp->bits, nbits);
}


static inline __attribute__((always_inline)) void __cpus_clear(cpumask_t *dstp, int nbits)
{
        bitmap_zero(dstp->bits, nbits);
}





static inline __attribute__((always_inline)) int __cpu_test_and_set(int cpu, cpumask_t *addr)
{
        return test_and_set_bit(cpu, addr->bits);
}


static inline __attribute__((always_inline)) void __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
}


static inline __attribute__((always_inline)) void __cpus_or(cpumask_t *dstp, const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
}


static inline __attribute__((always_inline)) void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
}



static inline __attribute__((always_inline)) void __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
}


static inline __attribute__((always_inline)) void __cpus_complement(cpumask_t *dstp,
                                        const cpumask_t *srcp, int nbits)
{
        bitmap_complement(dstp->bits, srcp->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpus_equal(const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        return bitmap_equal(src1p->bits, src2p->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpus_intersects(const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        return bitmap_intersects(src1p->bits, src2p->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpus_subset(const cpumask_t *src1p,
                                        const cpumask_t *src2p, int nbits)
{
        return bitmap_subset(src1p->bits, src2p->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpus_empty(const cpumask_t *srcp, int nbits)
{
        return bitmap_empty(srcp->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpus_full(const cpumask_t *srcp, int nbits)
{
        return bitmap_full(srcp->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpus_weight(const cpumask_t *srcp, int nbits)
{
        return bitmap_weight(srcp->bits, nbits);
}



static inline __attribute__((always_inline)) void __cpus_shift_right(cpumask_t *dstp,
                                        const cpumask_t *srcp, int n, int nbits)
{
        bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
}



static inline __attribute__((always_inline)) void __cpus_shift_left(cpumask_t *dstp,
                                        const cpumask_t *srcp, int n, int nbits)
{
        bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
}


static inline __attribute__((always_inline)) int __first_cpu(const cpumask_t *srcp, int nbits)
{
        return ({ int __x = (nbits); int __y = (((__builtin_constant_p(nbits) && nbits <= 64 ? (__scanbit(*(unsigned long *)srcp->bits,(nbits))) : find_first_bit(srcp->bits,nbits)))); __x < __y ? __x: __y; });
}


static inline __attribute__((always_inline)) int __next_cpu(int n, const cpumask_t *srcp, int nbits)
{
        return ({ int __x = (nbits); int __y = (((__builtin_constant_p(nbits) && nbits <= 64 ? ((n+1) + (__scanbit((*(unsigned long *)srcp->bits) >> (n+1),(nbits)-(n+1)))) : find_next_bit(srcp->bits,nbits,n+1)))); __x < __y ? __x: __y; });
}
# 265 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) int __cpumask_scnprintf(char *buf, int len,
                                        const cpumask_t *srcp, int nbits)
{
        return bitmap_scnprintf(buf, len, srcp->bits, nbits);
}



static inline __attribute__((always_inline)) int __cpumask_parse(const char *buf, int len,
                                        cpumask_t *dstp, int nbits)
{
        return bitmap_parse(buf, len, dstp->bits, nbits);
}
# 344 "include/linux/cpumask.h"
extern cpumask_t cpu_possible_map;
extern cpumask_t cpu_online_map;
extern cpumask_t cpu_present_map;
# 16 "include/linux/sched.h" 2


# 1 "include/asm/semaphore.h" 1
# 42 "include/asm/semaphore.h"
# 1 "include/linux/wait.h" 1
# 23 "include/linux/wait.h"
# 1 "include/linux/list.h" 1






# 1 "include/linux/prefetch.h" 1
# 58 "include/linux/prefetch.h"
static inline __attribute__((always_inline)) void prefetch_range(void *addr, size_t len)
{

        char *cp;
        char *end = addr + len;

        for (cp = addr; cp < end; cp += (4*(1 << (7))))
                prefetch(cp);

}
# 8 "include/linux/list.h" 2
# 28 "include/linux/list.h"
struct list_head {
        struct list_head *next, *prev;
};
# 47 "include/linux/list.h"
static inline __attribute__((always_inline)) void __list_add(struct list_head *new,
                              struct list_head *prev,
                              struct list_head *next)
{
        next->prev = new;
        new->next = next;
        new->prev = prev;
        prev->next = new;
}
# 65 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
{
        __list_add(new, head, head->next);
}
# 78 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add_tail(struct list_head *new, struct list_head *head)
{
        __list_add(new, head->prev, head);
}







static inline __attribute__((always_inline)) void __list_add_rcu(struct list_head * new,
                struct list_head * prev, struct list_head * next)
{
        new->next = next;
        new->prev = prev;
        asm volatile("sfence" ::: "memory");
        next->prev = new;
        prev->next = new;
}
# 115 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add_rcu(struct list_head *new, struct list_head *head)
{
        __list_add_rcu(new, head, head->next);
}
# 136 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add_tail_rcu(struct list_head *new,
                                        struct list_head *head)
{
        __list_add_rcu(new, head->prev, head);
}
# 149 "include/linux/list.h"
static inline __attribute__((always_inline)) void __list_del(struct list_head * prev, struct list_head * next)
{
        next->prev = prev;
        prev->next = next;
}







static inline __attribute__((always_inline)) void list_del(struct list_head *entry)
{
        __list_del(entry->prev, entry->next);
        entry->next = ((void *) 0x00100100);
        entry->prev = ((void *) 0x00200200);
}
# 192 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_del_rcu(struct list_head *entry)
{
        __list_del(entry->prev, entry->next);
        entry->prev = ((void *) 0x00200200);
}
# 205 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_replace_rcu(struct list_head *old, struct list_head *new){
        new->next = old->next;
        new->prev = old->prev;
        asm volatile("sfence" ::: "memory");
        new->next->prev = new;
        new->prev->next = new;
}





static inline __attribute__((always_inline)) void list_del_init(struct list_head *entry)
{
        __list_del(entry->prev, entry->next);
        do { (entry)->next = (entry); (entry)->prev = (entry); } while (0);
}






static inline __attribute__((always_inline)) void list_move(struct list_head *list, struct list_head *head)
{
        __list_del(list->prev, list->next);
        list_add(list, head);
}






static inline __attribute__((always_inline)) void list_move_tail(struct list_head *list,
                                  struct list_head *head)
{
        __list_del(list->prev, list->next);
        list_add_tail(list, head);
}





static inline __attribute__((always_inline)) int list_empty(const struct list_head *head)
{
        return head->next == head;
}
# 267 "include/linux/list.h"
static inline __attribute__((always_inline)) int list_empty_careful(const struct list_head *head)
{
        struct list_head *next = head->next;
        return (next == head) && (next == head->prev);
}

static inline __attribute__((always_inline)) void __list_splice(struct list_head *list,
                                 struct list_head *head)
{
        struct list_head *first = list->next;
        struct list_head *last = list->prev;
        struct list_head *at = head->next;

        first->prev = head;
        head->next = first;

        last->next = at;
        at->prev = last;
}






static inline __attribute__((always_inline)) void list_splice(struct list_head *list, struct list_head *head)
{
        if (!list_empty(list))
                __list_splice(list, head);
}
# 305 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_splice_init(struct list_head *list,
                                    struct list_head *head)
{
        if (!list_empty(list)) {
                __list_splice(list, head);
                do { (list)->next = (list); (list)->prev = (list); } while (0);
        }
}
# 499 "include/linux/list.h"
struct hlist_head {
        struct hlist_node *first;
};

struct hlist_node {
        struct hlist_node *next, **pprev;
};






static inline __attribute__((always_inline)) int hlist_unhashed(const struct hlist_node *h)
{
        return !h->pprev;
}

static inline __attribute__((always_inline)) int hlist_empty(const struct hlist_head *h)
{
        return !h->first;
}

static inline __attribute__((always_inline)) void __hlist_del(struct hlist_node *n)
{
        struct hlist_node *next = n->next;
        struct hlist_node **pprev = n->pprev;
        *pprev = next;
        if (next)
                next->pprev = pprev;
}

static inline __attribute__((always_inline)) void hlist_del(struct hlist_node *n)
{
        __hlist_del(n);
        n->next = ((void *) 0x00100100);
        n->pprev = ((void *) 0x00200200);
}
# 557 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_del_rcu(struct hlist_node *n)
{
        __hlist_del(n);
        n->pprev = ((void *) 0x00200200);
}

static inline __attribute__((always_inline)) void hlist_del_init(struct hlist_node *n)
{
        if (n->pprev) {
                __hlist_del(n);
                ((n)->next = ((void *)0), (n)->pprev = ((void *)0));
        }
}



static inline __attribute__((always_inline)) void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
{
        struct hlist_node *first = h->first;
        n->next = first;
        if (first)
                first->pprev = &n->next;
        h->first = n;
        n->pprev = &h->first;
}
# 600 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_add_head_rcu(struct hlist_node *n,
                                        struct hlist_head *h)
{
        struct hlist_node *first = h->first;
        n->next = first;
        n->pprev = &h->first;
        asm volatile("sfence" ::: "memory");
        if (first)
                first->pprev = &n->next;
        h->first = n;
}


static inline __attribute__((always_inline)) void hlist_add_before(struct hlist_node *n,
                                        struct hlist_node *next)
{
        n->pprev = next->pprev;
        n->next = next;
        next->pprev = &n->next;
        *(n->pprev) = n;
}

static inline __attribute__((always_inline)) void hlist_add_after(struct hlist_node *n,
                                        struct hlist_node *next)
{
        next->next = n->next;
        n->next = next;
        next->pprev = &n->next;

        if(next->next)
                next->next->pprev = &next->next;
}
# 24 "include/linux/wait.h" 2




typedef struct __wait_queue wait_queue_t;
typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key);
int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);

struct __wait_queue {
        unsigned int flags;

        struct task_struct * task;
        wait_queue_func_t func;
        struct list_head task_list;
};

struct __wait_queue_head {
        spinlock_t lock;
        struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
# 66 "include/linux/wait.h"
static inline __attribute__((always_inline)) void init_waitqueue_head(wait_queue_head_t *q)
{
        q->lock = (spinlock_t) { 1 };
        do { (&q->task_list)->next = (&q->task_list); (&q->task_list)->prev = (&q->task_list); } while (0);
}

static inline __attribute__((always_inline)) void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
{
        q->flags = 0;
        q->task = p;
        q->func = default_wake_function;
}

static inline __attribute__((always_inline)) void init_waitqueue_func_entry(wait_queue_t *q,
                                        wait_queue_func_t func)
{
        q->flags = 0;
        q->task = ((void *)0);
        q->func = func;
}

static inline __attribute__((always_inline)) int waitqueue_active(wait_queue_head_t *q)
{
        return !list_empty(&q->task_list);
}
# 101 "include/linux/wait.h"
extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait);
extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait);
extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait);

static inline __attribute__((always_inline)) void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
{
        list_add(&new->task_list, &head->task_list);
}




static inline __attribute__((always_inline)) void __add_wait_queue_tail(wait_queue_head_t *head,
                                                wait_queue_t *new)
{
        list_add_tail(&new->task_list, &head->task_list);
}

static inline __attribute__((always_inline)) void __remove_wait_queue(wait_queue_head_t *head,
                                                        wait_queue_t *old)
{
        list_del(&old->task_list);
}

void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
extern void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
# 266 "include/linux/wait.h"
static inline __attribute__((always_inline)) void add_wait_queue_exclusive_locked(wait_queue_head_t *q,
                                                   wait_queue_t * wait)
{
        wait->flags |= 0x01;
        __add_wait_queue_tail(q, wait);
}




static inline __attribute__((always_inline)) void remove_wait_queue_locked(wait_queue_head_t *q,
                                            wait_queue_t * wait)
{
        __remove_wait_queue(q, wait);
}






extern void sleep_on(wait_queue_head_t *q);
extern long sleep_on_timeout(wait_queue_head_t *q, signed long timeout);

extern void interruptible_sleep_on(wait_queue_head_t *q);
extern long interruptible_sleep_on_timeout(wait_queue_head_t *q, signed long timeout);





void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state);

void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state);

void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
# 43 "include/asm/semaphore.h" 2
# 1 "include/linux/rwsem.h" 1
# 22 "include/linux/rwsem.h"
struct rw_semaphore;


# 1 "include/linux/rwsem-spinlock.h" 1
# 22 "include/linux/rwsem-spinlock.h"
struct rwsem_waiter;
# 31 "include/linux/rwsem-spinlock.h"
struct rw_semaphore {
        __s32 activity;
        spinlock_t wait_lock;
        struct list_head wait_list;



};
# 55 "include/linux/rwsem-spinlock.h"
extern void init_rwsem(struct rw_semaphore *sem);
extern void __down_read(struct rw_semaphore *sem);
extern int __down_read_trylock(struct rw_semaphore *sem);
extern void __down_write(struct rw_semaphore *sem);
extern int __down_write_trylock(struct rw_semaphore *sem);
extern void __up_read(struct rw_semaphore *sem);
extern void __up_write(struct rw_semaphore *sem);
extern void __downgrade_write(struct rw_semaphore *sem);
# 26 "include/linux/rwsem.h" 2
# 41 "include/linux/rwsem.h"
static inline __attribute__((always_inline)) void down_read(struct rw_semaphore *sem)
{
        do {} while(0);
        ;
        __down_read(sem);
        ;
}




static inline __attribute__((always_inline)) int down_read_trylock(struct rw_semaphore *sem)
{
        int ret;
        ;
        ret = __down_read_trylock(sem);
        ;
        return ret;
}




static inline __attribute__((always_inline)) void down_write(struct rw_semaphore *sem)
{
        do {} while(0);
        ;
        __down_write(sem);
        ;
}




static inline __attribute__((always_inline)) int down_write_trylock(struct rw_semaphore *sem)
{
        int ret;
        ;
        ret = __down_write_trylock(sem);
        ;
        return ret;
}




static inline __attribute__((always_inline)) void up_read(struct rw_semaphore *sem)
{
        ;
        __up_read(sem);
        ;
}




static inline __attribute__((always_inline)) void up_write(struct rw_semaphore *sem)
{
        ;
        __up_write(sem);
        ;
}




static inline __attribute__((always_inline)) void downgrade_write(struct rw_semaphore *sem)
{
        ;
        __downgrade_write(sem);
        ;
}
# 44 "include/asm/semaphore.h" 2


struct semaphore {
        atomic_t count;
        int sleepers;
        wait_queue_head_t wait;
};
# 68 "include/asm/semaphore.h"
static inline __attribute__((always_inline)) void sema_init (struct semaphore *sem, int val)
{






        (((&sem->count)->counter) = (val));
        sem->sleepers = 0;
        init_waitqueue_head(&sem->wait);
}

static inline __attribute__((always_inline)) void init_MUTEX (struct semaphore *sem)
{
        sema_init(sem, 1);
}

static inline __attribute__((always_inline)) void init_MUTEX_LOCKED (struct semaphore *sem)
{
        sema_init(sem, 0);
}

 void __down_failed(void );
 int __down_failed_interruptible(void );
 int __down_failed_trylock(void );
 void __up_wakeup(void );

 void __down(struct semaphore * sem);
 int __down_interruptible(struct semaphore * sem);
 int __down_trylock(struct semaphore * sem);
 void __up(struct semaphore * sem);






static inline __attribute__((always_inline)) void down(struct semaphore * sem)
{
        do {} while(0);

        __asm__ __volatile__(
                "# atomic down operation\n\t"
                "lock ; " "decl %0\n\t"
                "js 2f\n"
                "1:\n"
                ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t"
                "2:\tcall __down_failed\n\t"
                "jmp 1b\n"
                ".previous\n\t"
                :"=m" (sem->count)
                :"D" (sem)
                :"memory");
}





static inline __attribute__((always_inline)) int down_interruptible(struct semaphore * sem)
{
        int result;

        do {} while(0);

        __asm__ __volatile__(
                "# atomic interruptible down operation\n\t"
                "lock ; " "decl %1\n\t"
                "js 2f\n\t"
                "xorl %0,%0\n"
                "1:\n"
                ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t"
                "2:\tcall __down_failed_interruptible\n\t"
                "jmp 1b\n"
                ".previous\n\t"
                :"=a" (result), "=m" (sem->count)
                :"D" (sem)
                :"memory");
        return result;
}





static inline __attribute__((always_inline)) int down_trylock(struct semaphore * sem)
{
        int result;

        __asm__ __volatile__(
                "# atomic interruptible down operation\n\t"
                "lock ; " "decl %1\n\t"
                "js 2f\n\t"
                "xorl %0,%0\n"
                "1:\n"
                ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t"
                "2:\tcall __down_failed_trylock\n\t"
                "jmp 1b\n"
                ".previous\n\t"
                :"=a" (result), "=m" (sem->count)
                :"D" (sem)
                :"memory","cc");
        return result;
}







static inline __attribute__((always_inline)) void up(struct semaphore * sem)
{
        __asm__ __volatile__(
                "# atomic up operation\n\t"
                "lock ; " "incl %0\n\t"
                "jle 2f\n"
                "1:\n"
                ".subsection 1\n\t" "" ".ifndef " ".text.lock." "radix_clear" "\n\t" ".text.lock." "radix_clear" ":\n\t" ".endif\n\t"
                "2:\tcall __up_wakeup\n\t"
                "jmp 1b\n"
                ".previous\n\t"
                :"=m" (sem->count)
                :"D" (sem)
                :"memory");
}
# 19 "include/linux/sched.h" 2

# 1 "include/asm/ptrace.h" 1
# 39 "include/asm/ptrace.h"
struct pt_regs {
        unsigned long r15;
        unsigned long r14;
        unsigned long r13;
        unsigned long r12;
        unsigned long rbp;
        unsigned long rbx;

        unsigned long r11;
        unsigned long r10;
        unsigned long r9;
        unsigned long r8;
        unsigned long rax;
        unsigned long rcx;
        unsigned long rdx;
        unsigned long rsi;
        unsigned long rdi;
        unsigned long orig_rax;


        unsigned long rip;
        unsigned long cs;
        unsigned long eflags;
        unsigned long rsp;
        unsigned long ss;

};
# 86 "include/asm/ptrace.h"
extern unsigned long profile_pc(struct pt_regs *regs);
void signal_fault(struct pt_regs *regs, void *frame, char *where);

enum {
        EF_CF = 0x00000001,
        EF_PF = 0x00000004,
        EF_AF = 0x00000010,
        EF_ZF = 0x00000040,
        EF_SF = 0x00000080,
        EF_TF = 0x00000100,
        EF_IE = 0x00000200,
        EF_DF = 0x00000400,
        EF_OF = 0x00000800,
        EF_IOPL = 0x00003000,
        EF_IOPL_RING0 = 0x00000000,
        EF_IOPL_RING1 = 0x00001000,
        EF_IOPL_RING2 = 0x00002000,
        EF_NT = 0x00004000,
        EF_RF = 0x00010000,
        EF_VM = 0x00020000,
        EF_AC = 0x00040000,
        EF_VIF = 0x00080000,
        EF_VIP = 0x00100000,
        EF_ID = 0x00200000,
};
# 21 "include/linux/sched.h" 2
# 1 "include/asm/mmu.h" 1
# 13 "include/asm/mmu.h"
typedef struct {
        void *ldt;
        rwlock_t ldtlock;
        int size;
        struct semaphore sem;
} mm_context_t;
# 22 "include/linux/sched.h" 2

# 1 "include/linux/smp.h" 1
# 17 "include/linux/smp.h"
# 1 "include/asm/smp.h" 1
# 12 "include/asm/smp.h"
extern int disable_apic;




# 1 "include/asm/fixmap.h" 1
# 16 "include/asm/fixmap.h"
# 1 "include/asm/apicdef.h" 1
# 123 "include/asm/apicdef.h"
struct local_apic {

        struct { unsigned int __reserved[4]; } __reserved_01;

        struct { unsigned int __reserved[4]; } __reserved_02;

        struct {
                unsigned int __reserved_1 : 24,
                        phys_apic_id : 4,
                        __reserved_2 : 4;
                unsigned int __reserved[3];
        } id;

        const
        struct {
                unsigned int version : 8,
                        __reserved_1 : 8,
                        max_lvt : 8,
                        __reserved_2 : 8;
                unsigned int __reserved[3];
        } version;

        struct { unsigned int __reserved[4]; } __reserved_03;

        struct { unsigned int __reserved[4]; } __reserved_04;

        struct { unsigned int __reserved[4]; } __reserved_05;

        struct { unsigned int __reserved[4]; } __reserved_06;

        struct {
                unsigned int priority : 8,
                        __reserved_1 : 24;
                unsigned int __reserved_2[3];
        } tpr;

        const
        struct {
                unsigned int priority : 8,
                        __reserved_1 : 24;
                unsigned int __reserved_2[3];
        } apr;

        const
        struct {
                unsigned int priority : 8,
                        __reserved_1 : 24;
                unsigned int __reserved_2[3];
        } ppr;

        struct {
                unsigned int eoi;
                unsigned int __reserved[3];
        } eoi;

        struct { unsigned int __reserved[4]; } __reserved_07;

        struct {
                unsigned int __reserved_1 : 24,
                        logical_dest : 8;
                unsigned int __reserved_2[3];
        } ldr;

        struct {
                unsigned int __reserved_1 : 28,
                        model : 4;
                unsigned int __reserved_2[3];
        } dfr;

        struct {
                unsigned int spurious_vector : 8,
                        apic_enabled : 1,
                        focus_cpu : 1,
                        __reserved_2 : 22;
                unsigned int __reserved_3[3];
        } svr;

        struct {
                unsigned int bitfield;
                unsigned int __reserved[3];
        } isr [8];

        struct {
                unsigned int bitfield;
                unsigned int __reserved[3];
        } tmr [8];

        struct {
                unsigned int bitfield;
                unsigned int __reserved[3];
        } irr [8];

        union {
                struct {
                        unsigned int send_cs_error : 1,
                                receive_cs_error : 1,
                                send_accept_error : 1,
                                receive_accept_error : 1,
                                __reserved_1 : 1,
                                send_illegal_vector : 1,
                                receive_illegal_vector : 1,
                                illegal_register_address : 1,
                                __reserved_2 : 24;
                        unsigned int __reserved_3[3];
                } error_bits;
                struct {
                        unsigned int errors;
                        unsigned int __reserved_3[3];
                } all_errors;
        } esr;

        struct { unsigned int __reserved[4]; } __reserved_08;

        struct { unsigned int __reserved[4]; } __reserved_09;

        struct { unsigned int __reserved[4]; } __reserved_10;

        struct { unsigned int __reserved[4]; } __reserved_11;

        struct { unsigned int __reserved[4]; } __reserved_12;

        struct { unsigned int __reserved[4]; } __reserved_13;

        struct { unsigned int __reserved[4]; } __reserved_14;

        struct {
                unsigned int vector : 8,
                        delivery_mode : 3,
                        destination_mode : 1,
                        delivery_status : 1,
                        __reserved_1 : 1,
                        level : 1,
                        trigger : 1,
                        __reserved_2 : 2,
                        shorthand : 2,
                        __reserved_3 : 12;
                unsigned int __reserved_4[3];
        } icr1;

        struct {
                union {
                        unsigned int __reserved_1 : 24,
                                phys_dest : 4,
                                __reserved_2 : 4;
                        unsigned int __reserved_3 : 24,
                                logical_dest : 8;
                } dest;
                unsigned int __reserved_4[3];
        } icr2;

        struct {
                unsigned int vector : 8,
                        __reserved_1 : 4,
                        delivery_status : 1,
                        __reserved_2 : 3,
                        mask : 1,
                        timer_mode : 1,
                        __reserved_3 : 14;
                unsigned int __reserved_4[3];
        } lvt_timer;

        struct {
                unsigned int vector : 8,
                        delivery_mode : 3,
                        __reserved_1 : 1,
                        delivery_status : 1,
                        __reserved_2 : 3,
                        mask : 1,
                        __reserved_3 : 15;
                unsigned int __reserved_4[3];
        } lvt_thermal;

        struct {
                unsigned int vector : 8,
                        delivery_mode : 3,
                        __reserved_1 : 1,
                        delivery_status : 1,
                        __reserved_2 : 3,
                        mask : 1,
                        __reserved_3 : 15;
                unsigned int __reserved_4[3];
        } lvt_pc;

        struct {
                unsigned int vector : 8,
                        delivery_mode : 3,
                        __reserved_1 : 1,
                        delivery_status : 1,
                        polarity : 1,
                        remote_irr : 1,
                        trigger : 1,
                        mask : 1,
                        __reserved_2 : 15;
                unsigned int __reserved_3[3];
        } lvt_lint0;

        struct {
                unsigned int vector : 8,
                        delivery_mode : 3,
                        __reserved_1 : 1,
                        delivery_status : 1,
                        polarity : 1,
                        remote_irr : 1,
                        trigger : 1,
                        mask : 1,
                        __reserved_2 : 15;
                unsigned int __reserved_3[3];
        } lvt_lint1;

        struct {
                unsigned int vector : 8,
                        __reserved_1 : 4,
                        delivery_status : 1,
                        __reserved_2 : 3,
                        mask : 1,
                        __reserved_3 : 15;
                unsigned int __reserved_4[3];
        } lvt_error;

        struct {
                unsigned int initial_count;
                unsigned int __reserved_2[3];
        } timer_icr;

        const
        struct {
                unsigned int curr_count;
                unsigned int __reserved_2[3];
        } timer_ccr;

        struct { unsigned int __reserved[4]; } __reserved_16;

        struct { unsigned int __reserved[4]; } __reserved_17;

        struct { unsigned int __reserved[4]; } __reserved_18;

        struct { unsigned int __reserved[4]; } __reserved_19;

        struct {
                unsigned int divisor : 4,
                        __reserved_1 : 28;
                unsigned int __reserved_2[3];
        } timer_dcr;

        struct { unsigned int __reserved[4]; } __reserved_20;

} __attribute__ ((packed));
# 17 "include/asm/fixmap.h" 2


# 1 "include/asm/vsyscall32.h" 1
# 20 "include/asm/fixmap.h" 2
# 36 "include/asm/fixmap.h"
enum fixed_addresses {
        VSYSCALL_LAST_PAGE,
        VSYSCALL_FIRST_PAGE = VSYSCALL_LAST_PAGE + (((-2UL << 20)-(-10UL << 20)) >> 12) - 1,
        VSYSCALL_HPET,
        FIX_HPET_BASE,

        FIX_APIC_BASE,


        FIX_IO_APIC_BASE_0,
        FIX_IO_APIC_BASE_END = FIX_IO_APIC_BASE_0 + 32 -1,

        __end_of_fixed_addresses
};

extern void __set_fixmap (enum fixed_addresses idx,
                                        unsigned long phys, pgprot_t flags);
# 72 "include/asm/fixmap.h"
extern void __this_fixmap_does_not_exist(void);






extern inline __attribute__((always_inline)) unsigned long fix_to_virt(const unsigned int idx)
{
# 90 "include/asm/fixmap.h"
        if (idx >= __end_of_fixed_addresses)
                __this_fixmap_does_not_exist();

        return (((-2UL << 20)-(1UL << 12)) - ((idx) << 12));
}
# 18 "include/asm/smp.h" 2
# 1 "include/asm/mpspec.h" 1
# 21 "include/asm/mpspec.h"
struct intel_mp_floating
{
        char mpf_signature[4];
        unsigned int mpf_physptr;
        unsigned char mpf_length;
        unsigned char mpf_specification;
        unsigned char mpf_checksum;
        unsigned char mpf_feature1;
        unsigned char mpf_feature2;
        unsigned char mpf_feature3;
        unsigned char mpf_feature4;
        unsigned char mpf_feature5;
};

struct mp_config_table
{
        char mpc_signature[4];

        unsigned short mpc_length;
        char mpc_spec;
        char mpc_checksum;
        char mpc_oem[8];
        char mpc_productid[12];
        unsigned int mpc_oemptr;
        unsigned short mpc_oemsize;
        unsigned short mpc_oemcount;
        unsigned int mpc_lapic;
        unsigned int reserved;
};
# 59 "include/asm/mpspec.h"
struct mpc_config_processor
{
        unsigned char mpc_type;
        unsigned char mpc_apicid;
        unsigned char mpc_apicver;
        unsigned char mpc_cpuflag;


        unsigned int mpc_cpufeature;



        unsigned int mpc_featureflag;
        unsigned int mpc_reserved[2];
};

struct mpc_config_bus
{
        unsigned char mpc_type;
        unsigned char mpc_busid;
        unsigned char mpc_bustype[6] __attribute((packed));
};
# 102 "include/asm/mpspec.h"
struct mpc_config_ioapic
{
        unsigned char mpc_type;
        unsigned char mpc_apicid;
        unsigned char mpc_apicver;
        unsigned char mpc_flags;

        unsigned int mpc_apicaddr;
};

struct mpc_config_intsrc
{
        unsigned char mpc_type;
        unsigned char mpc_irqtype;
        unsigned short mpc_irqflag;
        unsigned char mpc_srcbus;
        unsigned char mpc_srcbusirq;
        unsigned char mpc_dstapic;
        unsigned char mpc_dstirq;
};

enum mp_irq_source_types {
        mp_INT = 0,
        mp_NMI = 1,
        mp_SMI = 2,
        mp_ExtINT = 3
};






struct mpc_config_lintsrc
{
        unsigned char mpc_type;
        unsigned char mpc_irqtype;
        unsigned short mpc_irqflag;
        unsigned char mpc_srcbusid;
        unsigned char mpc_srcbusirq;
        unsigned char mpc_destapic;

        unsigned char mpc_destapiclint;
};
# 161 "include/asm/mpspec.h"
enum mp_bustype {
        MP_BUS_ISA = 1,
        MP_BUS_EISA,
        MP_BUS_PCI,
        MP_BUS_MCA
};
extern unsigned char mp_bus_id_to_type [270];
extern int mp_bus_id_to_pci_bus [270];

extern unsigned int boot_cpu_physical_apicid;
extern int smp_found_config;
extern void find_smp_config (void);
extern void get_smp_config (void);
extern int nr_ioapics;
extern int apic_version [16];
extern int mp_irq_entries;
extern struct mpc_config_intsrc mp_irqs [256];
extern int mpc_default_type;
extern int mp_current_pci_id;
extern unsigned long mp_lapic_addr;
extern int pic_mode;


extern void mp_register_lapic (u8 id, u8 enabled);
extern void mp_register_lapic_address (u64 address);


extern void mp_register_ioapic (u8 id, u32 address, u32 gsi_base);
extern void mp_override_legacy_irq (u8 bus_irq, u8 polarity, u8 trigger, u32 gsi);
extern void mp_config_acpi_legacy_irqs (void);
extern void mp_register_gsi (u32 gsi, int edge_level, int active_high_low);



extern int using_apic_timer;



struct physid_mask
{
        unsigned long mask[(((16)+64 -1)/64)];
};

typedef struct physid_mask physid_mask_t;
# 239 "include/asm/mpspec.h"
extern physid_mask_t phys_cpu_present_map;
# 19 "include/asm/smp.h" 2

# 1 "include/asm/io_apic.h" 1
# 17 "include/asm/io_apic.h"
static inline __attribute__((always_inline)) int use_pci_vector(void) {return 1;}
static inline __attribute__((always_inline)) void disable_edge_ioapic_vector(unsigned int vector) { }
static inline __attribute__((always_inline)) void mask_and_ack_level_ioapic_vector(unsigned int vector) { }
static inline __attribute__((always_inline)) void end_edge_ioapic_vector (unsigned int vector) { }
# 65 "include/asm/io_apic.h"
union IO_APIC_reg_00 {
        u32 raw;
        struct {
                u32 __reserved_2 : 14,
                        LTS : 1,
                        delivery_type : 1,
                        __reserved_1 : 8,
                        ID : 8;
        } __attribute__ ((packed)) bits;
};

union IO_APIC_reg_01 {
        u32 raw;
        struct {
                u32 version : 8,
                __reserved_2 : 7,
                PRQ : 1,
                entries : 8,
                __reserved_1 : 8;
        } __attribute__ ((packed)) bits;
};

union IO_APIC_reg_02 {
        u32 raw;
        struct {
                u32 __reserved_2 : 24,
                arbitration : 4,
                __reserved_1 : 4;
        } __attribute__ ((packed)) bits;
};

union IO_APIC_reg_03 {
        u32 raw;
        struct {
                u32 boot_DT : 1,
                        __reserved_1 : 31;
        } __attribute__ ((packed)) bits;
};




extern int nr_ioapics;
extern int nr_ioapic_registers[32];

enum ioapic_irq_destination_types {
        dest_Fixed = 0,
        dest_LowestPrio = 1,
        dest_SMI = 2,
        dest__reserved_1 = 3,
        dest_NMI = 4,
        dest_INIT = 5,
        dest__reserved_2 = 6,
        dest_ExtINT = 7
};

struct IO_APIC_route_entry {
        __u32 vector : 8,
                delivery_mode : 3,



                dest_mode : 1,
                delivery_status : 1,
                polarity : 1,
                irr : 1,
                trigger : 1,
                mask : 1,
                __reserved_2 : 15;

        union { struct { __u32
                                        __reserved_1 : 24,
                                        physical_dest : 4,
                                        __reserved_2 : 4;
                        } physical;

                        struct { __u32
                                        __reserved_1 : 24,
                                        logical_dest : 8;
                        } logical;
        } dest;

} __attribute__ ((packed));






extern struct mpc_config_ioapic mp_ioapics[32];


extern int mp_irq_entries;


extern struct mpc_config_intsrc mp_irqs[256];


extern int mpc_default_type;

static inline __attribute__((always_inline)) unsigned int io_apic_read(unsigned int apic, unsigned int reg)
{
        *((volatile int *)((((-2UL << 20)-(1UL << 12)) - ((FIX_IO_APIC_BASE_0 + apic) << 12)) + (mp_ioapics[apic].mpc_apicaddr & ~(~((1UL << 12)-1))))) = reg;
        return *(((volatile int *)((((-2UL << 20)-(1UL << 12)) - ((FIX_IO_APIC_BASE_0 + apic) << 12)) + (mp_ioapics[apic].mpc_apicaddr & ~(~((1UL << 12)-1)))))+4);
}

static inline __attribute__((always_inline)) void io_apic_write(unsigned int apic, unsigned int reg, unsigned int value)
{
        *((volatile int *)((((-2UL << 20)-(1UL << 12)) - ((FIX_IO_APIC_BASE_0 + apic) << 12)) + (mp_ioapics[apic].mpc_apicaddr & ~(~((1UL << 12)-1))))) = reg;
        *(((volatile int *)((((-2UL << 20)-(1UL << 12)) - ((FIX_IO_APIC_BASE_0 + apic) << 12)) + (mp_ioapics[apic].mpc_apicaddr & ~(~((1UL << 12)-1)))))+4) = value;
}





static inline __attribute__((always_inline)) void io_apic_modify(unsigned int apic, unsigned int value)
{
        *(((volatile int *)((((-2UL << 20)-(1UL << 12)) - ((FIX_IO_APIC_BASE_0 + apic) << 12)) + (mp_ioapics[apic].mpc_apicaddr & ~(~((1UL << 12)-1)))))+4) = value;
}





static inline __attribute__((always_inline)) void io_apic_sync(unsigned int apic)
{
        (void) *(((volatile int *)((((-2UL << 20)-(1UL << 12)) - ((FIX_IO_APIC_BASE_0 + apic) << 12)) + (mp_ioapics[apic].mpc_apicaddr & ~(~((1UL << 12)-1)))))+4);
}


extern int skip_ioapic_setup;
# 205 "include/asm/io_apic.h"
extern int io_apic_get_unique_id (int ioapic, int apic_id);
extern int io_apic_get_version (int ioapic);
extern int io_apic_get_redir_entries (int ioapic);
extern int io_apic_set_pci_routing (int ioapic, int pin, int irq, int, int);


extern int sis_apic_bug;





extern int assign_irq_vector(int irq);

void enable_NMI_through_LVT0 (void * dummy);
# 21 "include/asm/smp.h" 2

# 1 "include/asm/apic.h" 1




# 1 "include/linux/pm.h" 1
# 33 "include/linux/pm.h"
enum
{
        PM_SUSPEND,
        PM_RESUME,

        PM_SAVE_STATE,


        PM_SET_WAKEUP,


        PM_GET_RESOURCES,
        PM_SET_RESOURCES,


        PM_EJECT,
        PM_LOCK,
};

typedef int pm_request_t;




enum
{
        PM_UNKNOWN_DEV = 0,
        PM_SYS_DEV,
        PM_PCI_DEV,
        PM_USB_DEV,
        PM_SCSI_DEV,
        PM_ISA_DEV,
        PM_MTD_DEV,
};

typedef int pm_dev_t;




enum
{
        PM_SYS_UNKNOWN = 0x00000000,
        PM_SYS_KBC = 0x41d00303,
        PM_SYS_COM = 0x41d00500,
        PM_SYS_IRDA = 0x41d00510,
        PM_SYS_FDC = 0x41d00700,
        PM_SYS_VGA = 0x41d00900,
        PM_SYS_PCMCIA = 0x41d00e00,
};
# 92 "include/linux/pm.h"
struct pm_dev;

typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);




struct pm_dev
{
        pm_dev_t type;
        unsigned long id;
        pm_callback callback;
        void *data;

        unsigned long flags;
        unsigned long state;
        unsigned long prev_state;

        struct list_head entry;
};



extern int pm_active;






struct pm_dev *pm_register(pm_dev_t type,
                           unsigned long id,
                           pm_callback callback);




void pm_unregister(struct pm_dev *dev);




void pm_unregister_all(pm_callback callback);




int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data);




int pm_send_all(pm_request_t rqst, void *data);




struct pm_dev *pm_find(pm_dev_t type, struct pm_dev *from);

static inline __attribute__((always_inline)) void pm_access(struct pm_dev *dev) {}
static inline __attribute__((always_inline)) void pm_dev_idle(struct pm_dev *dev) {}
# 193 "include/linux/pm.h"
extern void (*pm_idle)(void);
extern void (*pm_power_off)(void);

enum {
        PM_SUSPEND_ON = 0,
        PM_SUSPEND_STANDBY = 1,

        PM_SUSPEND_MEM = 3,
        PM_SUSPEND_DISK = 4,
        PM_SUSPEND_MAX = 5,
};

enum {
        PM_DISK_FIRMWARE = 1,
        PM_DISK_PLATFORM,
        PM_DISK_SHUTDOWN,
        PM_DISK_REBOOT,
        PM_DISK_MAX,
};


struct pm_ops {
        u32 pm_disk_mode;
        int (*prepare)(u32 state);
        int (*enter)(u32 state);
        int (*finish)(u32 state);
};

extern void pm_set_ops(struct pm_ops *);

extern int pm_suspend(u32 state);






struct device;

struct dev_pm_info {
        u32 power_state;

        u32 prev_state;
        u8 * saved_state;
        atomic_t pm_users;
        struct device * pm_parent;
        struct list_head entry;

};

extern void device_pm_set_parent(struct device * dev, struct device * parent);

extern int device_suspend(u32 state);
extern int device_power_down(u32 state);
extern void device_power_up(void);
extern void device_resume(void);
# 6 "include/asm/apic.h" 2
# 19 "include/asm/apic.h"
extern int apic_verbosity;
# 34 "include/asm/apic.h"
struct pt_regs;





static __inline __attribute__((always_inline)) void apic_write(unsigned long reg, unsigned int v)
{
        *((volatile unsigned int *)((fix_to_virt(FIX_APIC_BASE))+reg)) = v;
}

static __inline __attribute__((always_inline)) void apic_write_atomic(unsigned long reg, unsigned int v)
{
        ((__typeof__(*((volatile unsigned int *)((fix_to_virt(FIX_APIC_BASE))+reg))))__xchg((unsigned long)(v),((volatile unsigned int *)((fix_to_virt(FIX_APIC_BASE))+reg)),sizeof(*((volatile unsigned int *)((fix_to_virt(FIX_APIC_BASE))+reg)))));
}

static __inline __attribute__((always_inline)) unsigned int apic_read(unsigned long reg)
{
        return *((volatile unsigned int *)((fix_to_virt(FIX_APIC_BASE))+reg));
}

static __inline__ __attribute__((always_inline)) void apic_wait_icr_idle(void)
{
        while ( apic_read( 0x300 ) & 0x01000 );
}





static inline __attribute__((always_inline)) void ack_APIC_irq(void)
{
# 74 "include/asm/apic.h"
        apic_write((0xB0),(0));
}

extern int get_maxlvt (void);
extern void clear_local_APIC (void);
extern void connect_bsp_APIC (void);
extern void disconnect_bsp_APIC (void);
extern void disable_local_APIC (void);
extern int verify_local_APIC (void);
extern void cache_APIC_registers (void);
extern void sync_Arb_IDs (void);
extern void init_bsp_APIC (void);
extern void setup_local_APIC (void);
extern void init_apic_mappings (void);
extern void smp_local_timer_interrupt (struct pt_regs * regs);
extern void setup_boot_APIC_clock (void);
extern void setup_secondary_APIC_clock (void);
extern void setup_apic_nmi_watchdog (void);
extern int reserve_lapic_nmi(void);
extern void release_lapic_nmi(void);
extern void disable_timer_nmi_watchdog(void);
extern void enable_timer_nmi_watchdog(void);
extern void nmi_watchdog_tick (struct pt_regs * regs, unsigned reason);
extern int APIC_init_uniprocessor (void);
extern void disable_APIC_timer(void);
extern void enable_APIC_timer(void);

extern int check_nmi_watchdog(void);
extern void nmi_watchdog_default(void);
extern int setup_nmi_watchdog(char *);

extern unsigned int nmi_watchdog;
# 116 "include/asm/apic.h"
extern unsigned boot_cpu_id;
# 23 "include/asm/smp.h" 2
# 32 "include/asm/smp.h"
struct pt_regs;





extern void smp_alloc_memory(void);
extern cpumask_t cpu_online_map;
extern volatile unsigned long smp_invalidate_needed;
extern int pic_mode;
extern int smp_num_siblings;
extern void smp_flush_tlb(void);
extern void smp_message_irq(int cpl, void *dev_id, struct pt_regs *regs);
extern void smp_send_reschedule(int cpu);
extern void smp_invalidate_rcv(void);
extern void (*mtrr_hook) (void);
extern void zap_low_mappings(void);
void smp_stop_cpu(void);
extern cpumask_t cpu_sibling_map[8];
extern char phys_proc_id[8];
# 61 "include/asm/smp.h"
extern cpumask_t cpu_callout_map;


static inline __attribute__((always_inline)) int num_booting_cpus(void)
{
        return __cpus_weight(&(cpu_callout_map), 8);
}



extern __inline __attribute__((always_inline)) int hard_smp_processor_id(void)
{

        return (((*(unsigned int *)((fix_to_virt(FIX_APIC_BASE))+0x20))>>24)&0x0F);
}






extern volatile char x86_cpu_to_apicid[8];

static inline __attribute__((always_inline)) char x86_apicid_to_cpu(char apicid)
{
        int i;

        for (i = 0; i < 8; ++i)
                if (x86_cpu_to_apicid[i] == apicid)
                        return i;

        return -1;
}



extern u8 bios_cpu_apicid[];

static inline __attribute__((always_inline)) int cpu_present_to_apicid(int mps_cpu)
{
        if (mps_cpu < 8)
                return (int)bios_cpu_apicid[mps_cpu];
        else
                return 0xFFu;
}
# 120 "include/asm/smp.h"
static inline __attribute__((always_inline)) unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
{
        return ((cpumask).bits)[0];
}
# 141 "include/asm/smp.h"
static __inline __attribute__((always_inline)) int logical_smp_processor_id(void)
{

        return (((*(unsigned long *)((fix_to_virt(FIX_APIC_BASE))+0xD0))>>24)&0xFF);
}
# 18 "include/linux/smp.h" 2
# 28 "include/linux/smp.h"
extern void smp_send_stop(void);




extern void smp_send_reschedule(int cpu);





extern void smp_prepare_cpus(unsigned int max_cpus);




extern int __cpu_up(unsigned int cpunum);




extern void smp_cpus_done(unsigned int max_cpus);




extern int smp_call_function (void (*func) (void *info), void *info,
                              int retry, int wait);




static inline __attribute__((always_inline)) int on_each_cpu(void (*func) (void *info), void *info,
                              int retry, int wait)
{
        int ret = 0;

        do { } while (0);
        ret = smp_call_function(func, info, retry, wait);
        func(info);
        do { } while (0);
        return ret;
}




extern int smp_threads_ready;
# 91 "include/linux/smp.h"
void smp_prepare_boot_cpu(void);
# 24 "include/linux/sched.h" 2
# 1 "include/linux/sem.h" 1



# 1 "include/linux/ipc.h" 1
# 9 "include/linux/ipc.h"
struct ipc_perm
{
        __kernel_key_t key;
        __kernel_uid_t uid;
        __kernel_gid_t gid;
        __kernel_uid_t cuid;
        __kernel_gid_t cgid;
        __kernel_mode_t mode;
        unsigned short seq;
};


# 1 "include/asm/ipcbuf.h" 1
# 14 "include/asm/ipcbuf.h"
struct ipc64_perm
{
        __kernel_key_t key;
        __kernel_uid32_t uid;
        __kernel_gid32_t gid;
        __kernel_uid32_t cuid;
        __kernel_gid32_t cgid;
        __kernel_mode_t mode;
        unsigned short __pad1;
        unsigned short seq;
        unsigned short __pad2;
        unsigned long __unused1;
        unsigned long __unused2;
};
# 22 "include/linux/ipc.h" 2
# 57 "include/linux/ipc.h"
struct kern_ipc_perm
{
        spinlock_t lock;
        int deleted;
        key_t key;
        uid_t uid;
        gid_t gid;
        uid_t cuid;
        gid_t cgid;
        mode_t mode;
        unsigned long seq;
        void *security;
};
# 5 "include/linux/sem.h" 2
# 24 "include/linux/sem.h"
struct semid_ds {
        struct ipc_perm sem_perm;
        __kernel_time_t sem_otime;
        __kernel_time_t sem_ctime;
        struct sem *sem_base;
        struct sem_queue *sem_pending;
        struct sem_queue **sem_pending_last;
        struct sem_undo *undo;
        unsigned short sem_nsems;
};


# 1 "include/asm/sembuf.h" 1
# 14 "include/asm/sembuf.h"
struct semid64_ds {
        struct ipc64_perm sem_perm;
        __kernel_time_t sem_otime;
        unsigned long __unused1;
        __kernel_time_t sem_ctime;
        unsigned long __unused2;
        unsigned long sem_nsems;
        unsigned long __unused3;
        unsigned long __unused4;
};
# 37 "include/linux/sem.h" 2


struct sembuf {
        unsigned short sem_num;
        short sem_op;
        short sem_flg;
};


union semun {
        int val;
        struct semid_ds *buf;
        unsigned short *array;
        struct seminfo *__buf;
        void *__pad;
};

struct seminfo {
        int semmap;
        int semmni;
        int semmns;
        int semmnu;
        int semmsl;
        int semopm;
        int semume;
        int semusz;
        int semvmx;
        int semaem;
};
# 83 "include/linux/sem.h"
struct sem {
        int semval;
        int sempid;
};


struct sem_array {
        struct kern_ipc_perm sem_perm;
        time_t sem_otime;
        time_t sem_ctime;
        struct sem *sem_base;
        struct sem_queue *sem_pending;
        struct sem_queue **sem_pending_last;
        struct sem_undo *undo;
        unsigned long sem_nsems;
};


struct sem_queue {
        struct sem_queue * next;
        struct sem_queue ** prev;
        struct task_struct* sleeper;
        struct sem_undo * undo;
        int pid;
        int status;
        struct sem_array * sma;
        int id;
        struct sembuf * sops;
        int nsops;
};




struct sem_undo {
        struct sem_undo * proc_next;
        struct sem_undo * id_next;
        int semid;
        short * semadj;
};




struct sem_undo_list {
        atomic_t refcnt;
        spinlock_t lock;
        struct sem_undo *proc_list;
};

struct sysv_sem {
        struct sem_undo_list *undo_list;
};



extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
extern void exit_sem(struct task_struct *tsk);
# 25 "include/linux/sched.h" 2
# 1 "include/linux/signal.h" 1





# 1 "include/asm/signal.h" 1
# 10 "include/asm/signal.h"
struct siginfo;
# 20 "include/asm/signal.h"
typedef unsigned long old_sigset_t;

typedef struct {
        unsigned long sig[(64 / 64)];
} sigset_t;


struct pt_regs;
 int do_signal(struct pt_regs *regs, sigset_t *oldset);
# 139 "include/asm/signal.h"
typedef void __signalfn_t(int);
typedef __signalfn_t *__sighandler_t;

typedef void __restorefn_t(void);
typedef __restorefn_t *__sigrestore_t;





struct sigaction {
        __sighandler_t sa_handler;
        unsigned long sa_flags;
        __sigrestore_t sa_restorer;
        sigset_t sa_mask;
};

struct k_sigaction {
        struct sigaction sa;
};

typedef struct sigaltstack {
        void *ss_sp;
        int ss_flags;
        size_t ss_size;
} stack_t;
# 7 "include/linux/signal.h" 2
# 1 "include/asm/siginfo.h" 1







# 1 "include/asm-generic/siginfo.h" 1





# 1 "include/linux/resource.h" 1
# 21 "include/linux/resource.h"
struct rusage {
        struct timeval ru_utime;
        struct timeval ru_stime;
        long ru_maxrss;
        long ru_ixrss;
        long ru_idrss;
        long ru_isrss;
        long ru_minflt;
        long ru_majflt;
        long ru_nswap;
        long ru_inblock;
        long ru_oublock;
        long ru_msgsnd;
        long ru_msgrcv;
        long ru_nsignals;
        long ru_nvcsw;
        long ru_nivcsw;
};

struct rlimit {
        unsigned long rlim_cur;
        unsigned long rlim_max;
};
# 68 "include/linux/resource.h"
# 1 "include/asm/resource.h" 1
# 69 "include/linux/resource.h" 2
# 7 "include/asm-generic/siginfo.h" 2

typedef union sigval {
        int sival_int;
        void *sival_ptr;
} sigval_t;
# 41 "include/asm-generic/siginfo.h"
typedef struct siginfo {
        int si_signo;
        int si_errno;
        int si_code;

        union {
                int _pad[((128 - (4 * sizeof(int))) / sizeof(int))];


                struct {
                        pid_t _pid;
                        uid_t _uid;
                } _kill;


                struct {
                        timer_t _tid;
                        int _overrun;
                        char _pad[sizeof( uid_t) - sizeof(int)];
                        sigval_t _sigval;
                        int _sys_private;
                } _timer;


                struct {
                        pid_t _pid;
                        uid_t _uid;
                        sigval_t _sigval;
                } _rt;


                struct {
                        pid_t _pid;
                        uid_t _uid;
                        int _status;
                        clock_t _utime;
                        clock_t _stime;
                } _sigchld;


                struct {
                        void *_addr;



                } _sigfault;


                struct {
                        long _band;
                        int _fd;
                } _sigpoll;
        } _sifields;
} siginfo_t;
# 250 "include/asm-generic/siginfo.h"
typedef struct sigevent {
        sigval_t sigev_value;
        int sigev_signo;
        int sigev_notify;
        union {
                int _pad[((64/sizeof(int)) - 4)];
                 int _tid;

                struct {
                        void (*_function)(sigval_t);
                        void *_attribute;
                } _sigev_thread;
        } _sigev_un;
} sigevent_t;
# 273 "include/asm-generic/siginfo.h"
struct siginfo;
void do_schedule_next_timer(struct siginfo *info);





static inline __attribute__((always_inline)) void copy_siginfo(struct siginfo *to, struct siginfo *from)
{
        if (from->si_code < 0)
                ({ size_t __len = (sizeof(*to)); void *__ret; if (__builtin_constant_p(sizeof(*to)) && __len >= 64) __ret = __memcpy((to),(from),__len); else __ret = __builtin_memcpy((to),(from),__len); __ret; });
        else

                ({ size_t __len = ((4 * sizeof(int)) + sizeof(from->_sifields._sigchld)); void *__ret; if (__builtin_constant_p((4 * sizeof(int)) + sizeof(from->_sifields._sigchld)) && __len >= 64) __ret = __memcpy((to),(from),__len); else __ret = __builtin_memcpy((to),(from),__len); __ret; });
}



extern int copy_siginfo_to_user(struct siginfo *to, struct siginfo *from);
# 9 "include/asm/siginfo.h" 2
# 8 "include/linux/signal.h" 2
# 17 "include/linux/signal.h"
struct sigqueue {
        struct list_head list;
        spinlock_t *lock;
        int flags;
        siginfo_t info;
        struct user_struct *user;
};




struct sigpending {
        struct list_head list;
        sigset_t signal;
};
# 42 "include/linux/signal.h"
static inline __attribute__((always_inline)) void sigaddset(sigset_t *set, int _sig)
{
        unsigned long sig = _sig - 1;
        if ((64 / 64) == 1)
                set->sig[0] |= 1UL << sig;
        else
                set->sig[sig / 64] |= 1UL << (sig % 64);
}

static inline __attribute__((always_inline)) void sigdelset(sigset_t *set, int _sig)
{
        unsigned long sig = _sig - 1;
        if ((64 / 64) == 1)
                set->sig[0] &= ~(1UL << sig);
        else
                set->sig[sig / 64] &= ~(1UL << (sig % 64));
}

static inline __attribute__((always_inline)) int sigismember(sigset_t *set, int _sig)
{
        unsigned long sig = _sig - 1;
        if ((64 / 64) == 1)
                return 1 & (set->sig[0] >> sig);
        else
                return 1 & (set->sig[sig / 64] >> (sig % 64));
}

static inline __attribute__((always_inline)) int sigfindinword(unsigned long word)
{
        return ffz(~word);
}
# 106 "include/linux/signal.h"
static inline __attribute__((always_inline)) void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) | (b3)); r->sig[2] = ((a2) | (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) | (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) | (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }


static inline __attribute__((always_inline)) void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & (b3)); r->sig[2] = ((a2) & (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }


static inline __attribute__((always_inline)) void signandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & ~(b3)); r->sig[2] = ((a2) & ~(b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & ~(b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & ~(b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
# 136 "include/linux/signal.h"
static inline __attribute__((always_inline)) void signotset(sigset_t *set) { extern void _NSIG_WORDS_is_unsupported_size(void); switch ((64 / 64)) { case 4: set->sig[3] = (~(set->sig[3])); set->sig[2] = (~(set->sig[2])); case 2: set->sig[1] = (~(set->sig[1])); case 1: set->sig[0] = (~(set->sig[0])); break; default: _NSIG_WORDS_is_unsupported_size(); } }




static inline __attribute__((always_inline)) void sigemptyset(sigset_t *set)
{
        switch ((64 / 64)) {
        default:
                __builtin_memset(set, 0, sizeof(sigset_t));
                break;
        case 2: set->sig[1] = 0;
        case 1: set->sig[0] = 0;
                break;
        }
}

static inline __attribute__((always_inline)) void sigfillset(sigset_t *set)
{
        switch ((64 / 64)) {
        default:
                __builtin_memset(set, -1, sizeof(sigset_t));
                break;
        case 2: set->sig[1] = -1;
        case 1: set->sig[0] = -1;
                break;
        }
}



static inline __attribute__((always_inline)) void sigaddsetmask(sigset_t *set, unsigned long mask)
{
        set->sig[0] |= mask;
}

static inline __attribute__((always_inline)) void sigdelsetmask(sigset_t *set, unsigned long mask)
{
        set->sig[0] &= ~mask;
}

static inline __attribute__((always_inline)) int sigtestsetmask(sigset_t *set, unsigned long mask)
{
        return (set->sig[0] & mask) != 0;
}

static inline __attribute__((always_inline)) void siginitset(sigset_t *set, unsigned long mask)
{
        set->sig[0] = mask;
        switch ((64 / 64)) {
        default:
                __builtin_memset(&set->sig[1], 0, sizeof(long)*((64 / 64)-1));
                break;
        case 2: set->sig[1] = 0;
        case 1: ;
        }
}

static inline __attribute__((always_inline)) void siginitsetinv(sigset_t *set, unsigned long mask)
{
        set->sig[0] = ~mask;
        switch ((64 / 64)) {
        default:
                __builtin_memset(&set->sig[1], -1, sizeof(long)*((64 / 64)-1));
                break;
        case 2: set->sig[1] = -1;
        case 1: ;
        }
}



static inline __attribute__((always_inline)) void init_sigpending(struct sigpending *sig)
{
        sigemptyset(&sig->signal);
        do { (&sig->list)->next = (&sig->list); (&sig->list)->prev = (&sig->list); } while (0);
}

extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
extern long do_sigpending(void *, unsigned long);
extern int sigprocmask(int, sigset_t *, sigset_t *);


struct pt_regs;
extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
# 26 "include/linux/sched.h" 2
# 1 "include/linux/securebits.h" 1





extern unsigned securebits;
# 27 "include/linux/sched.h" 2
# 1 "include/linux/fs_struct.h" 1



struct dentry;
struct vfsmount;

struct fs_struct {
        atomic_t count;
        rwlock_t lock;
        int umask;
        struct dentry * root, * pwd, * altroot;
        struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
};







extern void exit_fs(struct task_struct *);
extern void set_fs_altroot(void);
extern void set_fs_root(struct fs_struct *, struct vfsmount *, struct dentry *);
extern void set_fs_pwd(struct fs_struct *, struct vfsmount *, struct dentry *);
extern struct fs_struct *copy_fs_struct(struct fs_struct *);
extern void put_fs_struct(struct fs_struct *);
# 28 "include/linux/sched.h" 2

# 1 "include/linux/completion.h" 1
# 13 "include/linux/completion.h"
struct completion {
        unsigned int done;
        wait_queue_head_t wait;
};







static inline __attribute__((always_inline)) void init_completion(struct completion *x)
{
        x->done = 0;
        init_waitqueue_head(&x->wait);
}

extern void wait_for_completion(struct completion *);
extern void complete(struct completion *);
extern void complete_all(struct completion *);
# 30 "include/linux/sched.h" 2
# 1 "include/linux/pid.h" 1



enum pid_type
{
        PIDTYPE_PID,
        PIDTYPE_TGID,
        PIDTYPE_PGID,
        PIDTYPE_SID,
        PIDTYPE_MAX
};

struct pid
{

        int nr;
        struct hlist_node pid_chain;

        struct list_head pid_list;
};
# 29 "include/linux/pid.h"
extern int attach_pid(struct task_struct *task, enum pid_type type, int nr);

extern void detach_pid(struct task_struct *task, enum pid_type);





extern struct pid *find_pid(enum pid_type, int);

extern int alloc_pidmap(void);
extern void free_pidmap(int);
extern void switch_exec_pids(struct task_struct *leader, struct task_struct *thread);
# 31 "include/linux/sched.h" 2
# 1 "include/linux/percpu.h" 1



# 1 "include/linux/slab.h" 1
# 12 "include/linux/slab.h"
typedef struct kmem_cache_s kmem_cache_t;


# 1 "include/linux/gfp.h" 1



# 1 "include/linux/mmzone.h" 1
# 13 "include/linux/mmzone.h"
# 1 "include/linux/numa.h" 1






# 1 "include/asm/numnodes.h" 1
# 8 "include/linux/numa.h" 2
# 14 "include/linux/mmzone.h" 2
# 23 "include/linux/mmzone.h"
struct free_area {
        struct list_head free_list;
        unsigned long *map;
};

struct pglist_data;
# 37 "include/linux/mmzone.h"
struct zone_padding {
        int x;
} __attribute__((__aligned__(1 << (6))));





struct per_cpu_pages {
        int count;
        int low;
        int high;
        int batch;
        struct list_head list;
};

struct per_cpu_pageset {
        struct per_cpu_pages pcp[2];

        unsigned long numa_hit;
        unsigned long numa_miss;
        unsigned long numa_foreign;
        unsigned long interleave_hit;
        unsigned long local_node;
        unsigned long other_node;

} __attribute__((__aligned__((1 << (7)))));
# 110 "include/linux/mmzone.h"
struct zone {



        spinlock_t lock;
        unsigned long free_pages;
        unsigned long pages_min, pages_low, pages_high;
# 129 "include/linux/mmzone.h"
        unsigned long protection[3];

        struct zone_padding _pad1_;

        spinlock_t lru_lock;
        struct list_head active_list;
        struct list_head inactive_list;
        unsigned long nr_scan_active;
        unsigned long nr_scan_inactive;
        unsigned long nr_active;
        unsigned long nr_inactive;
        int all_unreclaimable;
        unsigned long pages_scanned;

        struct zone_padding _pad2_;
# 161 "include/linux/mmzone.h"
        int temp_priority;
        int prev_priority;




        struct free_area free_area[11];
# 193 "include/linux/mmzone.h"
        wait_queue_head_t * wait_table;
        unsigned long wait_table_size;
        unsigned long wait_table_bits;

        struct zone_padding _pad3_;

        struct per_cpu_pageset pageset[8];




        struct pglist_data *zone_pgdat;
        struct page *zone_mem_map;

        unsigned long zone_start_pfn;




        char *name;
        unsigned long spanned_pages;
        unsigned long present_pages;
} __attribute__((__aligned__(1 << (6))));
# 236 "include/linux/mmzone.h"
struct zonelist {
        struct zone *zones[(1 << 3) * 3 + 1];
};
# 252 "include/linux/mmzone.h"
struct bootmem_data;
typedef struct pglist_data {
        struct zone node_zones[3];
        struct zonelist node_zonelists[((0x03 + 1) / 2 + 1)];
        int nr_zones;
        struct page *node_mem_map;
        struct bootmem_data *bdata;
        unsigned long node_start_pfn;
        unsigned long node_present_pages;
        unsigned long node_spanned_pages;

        int node_id;
        struct pglist_data *pgdat_next;
        wait_queue_head_t kswapd_wait;
        struct task_struct *kswapd;
} pg_data_t;




extern int numnodes;
extern struct pglist_data *pgdat_list;

void __get_zone_counts(unsigned long *active, unsigned long *inactive,
                        unsigned long *free, struct pglist_data *pgdat);
void get_zone_counts(unsigned long *active, unsigned long *inactive,
                        unsigned long *free);
void build_all_zonelists(void);
void wakeup_kswapd(struct zone *zone);
# 305 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) struct zone *next_zone(struct zone *zone)
{
        pg_data_t *pgdat = zone->zone_pgdat;

        if (zone - pgdat->node_zones < 3 - 1)
                zone++;
        else if (pgdat->pgdat_next) {
                pgdat = pgdat->pgdat_next;
                zone = pgdat->node_zones;
        } else
                zone = ((void *)0);

        return zone;
}
# 338 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) int is_highmem_idx(int idx)
{
        return (idx == 2);
}

static inline __attribute__((always_inline)) int is_normal_idx(int idx)
{
        return (idx == 1);
}






static inline __attribute__((always_inline)) int is_highmem(struct zone *zone)
{
        return (is_highmem_idx(zone - zone->zone_pgdat->node_zones));
}

static inline __attribute__((always_inline)) int is_normal(struct zone *zone)
{
        return (is_normal_idx(zone - zone->zone_pgdat->node_zones));
}


struct ctl_table;
struct file;
int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *,
                                        void *, size_t *, loff_t *);
int lower_zone_protection_sysctl_handler(struct ctl_table *, int, struct file *,
                                        void *, size_t *, loff_t *);

# 1 "include/linux/topology.h" 1
# 32 "include/linux/topology.h"
# 1 "include/linux/mmzone.h" 1
# 33 "include/linux/topology.h" 2


# 1 "include/asm/topology.h" 1
# 13 "include/asm/topology.h"
extern cpumask_t cpu_online_map;

extern unsigned char cpu_to_node[];
extern cpumask_t node_to_cpumask[];
extern cpumask_t pci_bus_to_cpumask[];






static inline __attribute__((always_inline)) cpumask_t __pcibus_to_cpumask(int bus)
{
        cpumask_t busmask = pci_bus_to_cpumask[bus];
        cpumask_t online = cpu_online_map;
        cpumask_t res;
        __cpus_and(&(res), &(busmask), &(online), 8);
        return res;
}







# 1 "include/asm-generic/topology.h" 1
# 40 "include/asm/topology.h" 2
# 36 "include/linux/topology.h" 2
# 46 "include/linux/topology.h"
static inline __attribute__((always_inline)) int __next_node_with_cpus(int node)
{
        do
                ++node;
        while (node < numnodes && !({ cpumask_t __tmp__; __tmp__ = (node_to_cpumask[node]); __cpus_weight(&(__tmp__), 8); }));
        return node;
}
# 372 "include/linux/mmzone.h" 2
# 385 "include/linux/mmzone.h"
# 1 "include/asm/mmzone.h" 1
# 19 "include/asm/mmzone.h"
extern int memnode_shift;
extern u8 memnodemap[0xff];
extern int maxnode;

extern struct pglist_data *node_data[];

static inline __attribute__((always_inline)) __attribute__((pure)) int phys_to_nid(unsigned long addr)
{
        int nid;
        ;
        nid = memnodemap[addr >> memnode_shift];
        ;
        return nid;
}
# 386 "include/linux/mmzone.h" 2
# 413 "include/linux/mmzone.h"
extern unsigned long node_online_map[((((1 << 3))+64 -1)/64)];






static inline __attribute__((always_inline)) unsigned int num_online_nodes(void)
{
        int i, num = 0;

        for(i = 0; i < (1 << 3); i++){
                if ((__builtin_constant_p(i) ? constant_test_bit((i),(node_online_map)) : variable_test_bit((i),(node_online_map))))
                        num++;
        }
        return num;
}
# 5 "include/linux/gfp.h" 2




struct vm_area_struct;
# 78 "include/linux/gfp.h"
static inline __attribute__((always_inline)) void arch_free_page(struct page *page, int order) { }


extern struct page *
__alloc_pages(unsigned int, unsigned int, struct zonelist *);

static inline __attribute__((always_inline)) struct page *alloc_pages_node(int nid, unsigned int gfp_mask,
                                                unsigned int order)
{
        if (__builtin_expect(!!(order >= 11), 0))
                return ((void *)0);

        return __alloc_pages(gfp_mask, order,
                (node_data[nid])->node_zonelists + (gfp_mask & 0x03));
}


extern struct page *alloc_pages_current(unsigned gfp_mask, unsigned order);

static inline __attribute__((always_inline)) struct page *
alloc_pages(unsigned int gfp_mask, unsigned int order)
{
        if (__builtin_expect(!!(order >= 11), 0))
                return ((void *)0);

        return alloc_pages_current(gfp_mask, order);
}
extern struct page *alloc_page_vma(unsigned gfp_mask,
                        struct vm_area_struct *vma, unsigned long addr);







extern unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order);
extern unsigned long get_zeroed_page(unsigned int gfp_mask);







extern void __free_pages(struct page *page, unsigned int order);
extern void free_pages(unsigned long addr, unsigned int order);
extern void free_hot_page(struct page *page);
extern void free_cold_page(struct page *page);




void page_alloc_init(void);
# 16 "include/linux/slab.h" 2
# 56 "include/linux/slab.h"
extern void kmem_cache_init(void);

extern kmem_cache_t *kmem_cache_create(const char *, size_t, size_t, unsigned long,
                                       void (*)(void *, kmem_cache_t *, unsigned long),
                                       void (*)(void *, kmem_cache_t *, unsigned long));
extern int kmem_cache_destroy(kmem_cache_t *);
extern int kmem_cache_shrink(kmem_cache_t *);
extern void *kmem_cache_alloc(kmem_cache_t *, int);
extern void *kmem_cache_alloc_node(kmem_cache_t *, int);
extern void kmem_cache_free(kmem_cache_t *, void *);
extern unsigned int kmem_cache_size(kmem_cache_t *);


struct cache_sizes {
        size_t cs_size;
        kmem_cache_t *cs_cachep;
        kmem_cache_t *cs_dmacachep;
};
extern struct cache_sizes malloc_sizes[];
extern void *__kmalloc(size_t, int);

static inline __attribute__((always_inline)) void *kmalloc(size_t size, int flags)
{
        if (__builtin_constant_p(size)) {
                int i = 0;





# 1 "include/linux/kmalloc_sizes.h" 1

        if (size <= 32) goto found; else i++;

        if (size <= 64) goto found; else i++;



        if (size <= 128) goto found; else i++;



        if (size <= 256) goto found; else i++;
        if (size <= 512) goto found; else i++;
        if (size <= 1024) goto found; else i++;
        if (size <= 2048) goto found; else i++;
        if (size <= 4096) goto found; else i++;
        if (size <= 8192) goto found; else i++;
        if (size <= 16384) goto found; else i++;
        if (size <= 32768) goto found; else i++;
        if (size <= 65536) goto found; else i++;
        if (size <= 131072) goto found; else i++;
# 87 "include/linux/slab.h" 2

                {
                        extern void __you_cannot_kmalloc_that_much(void);
                        __you_cannot_kmalloc_that_much();
                }
found:
                return kmem_cache_alloc((flags & 0x01) ?
                        malloc_sizes[i].cs_dmacachep :
                        malloc_sizes[i].cs_cachep, flags);
        }
        return __kmalloc(size, flags);
}

extern void *kcalloc(size_t, size_t, int);
extern void kfree(const void *);
extern unsigned int ksize(const void *);

extern int kmem_cache_reap(int);
extern int kmem_ptr_validate(kmem_cache_t *cachep, void *ptr);


extern kmem_cache_t *vm_area_cachep;
extern kmem_cache_t *mm_cachep;
extern kmem_cache_t *names_cachep;
extern kmem_cache_t *files_cachep;
extern kmem_cache_t *filp_cachep;
extern kmem_cache_t *dquot_cachep;
extern kmem_cache_t *fs_cachep;
extern kmem_cache_t *signal_cachep;
extern kmem_cache_t *sighand_cachep;
extern kmem_cache_t *bio_cachep;

extern atomic_t slab_reclaim_pages;
# 5 "include/linux/percpu.h" 2
# 20 "include/linux/percpu.h"
struct percpu_data {
        void *ptrs[8];
        void *blkp;
};
# 36 "include/linux/percpu.h"
extern void *__alloc_percpu(size_t size, size_t align);
extern void free_percpu(const void *);
# 32 "include/linux/sched.h" 2

struct exec_domain;
# 73 "include/linux/sched.h"
extern unsigned long avenrun[];
# 90 "include/linux/sched.h"
extern int nr_threads;
extern int last_pid;
extern __typeof__(unsigned long) per_cpu__process_counts;
extern int nr_processes(void);
extern unsigned long nr_running(void);
extern unsigned long nr_uninterruptible(void);
extern unsigned long nr_iowait(void);


# 1 "include/linux/param.h" 1
# 100 "include/linux/sched.h" 2

# 1 "include/linux/timer.h" 1
# 9 "include/linux/timer.h"
struct tvec_t_base_s;

struct timer_list {
        struct list_head entry;
        unsigned long expires;

        spinlock_t lock;
        unsigned long magic;

        void (*function)(unsigned long);
        unsigned long data;

        struct tvec_t_base_s *base;
};
# 42 "include/linux/timer.h"
static inline __attribute__((always_inline)) void init_timer(struct timer_list * timer)
{
        timer->base = ((void *)0);
        timer->magic = 0x4b87ad6e;
        do { *(&timer->lock) = (spinlock_t) { 1 }; } while(0);
}
# 59 "include/linux/timer.h"
static inline __attribute__((always_inline)) int timer_pending(const struct timer_list * timer)
{
        return timer->base != ((void *)0);
}

extern void add_timer_on(struct timer_list *timer, int cpu);
extern int del_timer(struct timer_list * timer);
extern int __mod_timer(struct timer_list *timer, unsigned long expires);
extern int mod_timer(struct timer_list *timer, unsigned long expires);

extern unsigned long next_timer_interrupt(void);
# 85 "include/linux/timer.h"
static inline __attribute__((always_inline)) void add_timer(struct timer_list * timer)
{
        __mod_timer(timer, timer->expires);
}


  extern int del_timer_sync(struct timer_list *timer);
  extern int del_singleshot_timer_sync(struct timer_list *timer);





extern void init_timers(void);
extern void run_local_timers(void);
extern void it_real_fn(unsigned long);
# 102 "include/linux/sched.h" 2
# 130 "include/linux/sched.h"
struct sched_param {
        int sched_priority;
};
# 144 "include/linux/sched.h"
extern rwlock_t tasklist_lock;
extern spinlock_t mmlist_lock;

typedef struct task_struct task_t;

extern void sched_init(void);
extern void sched_init_smp(void);
extern void init_idle(task_t *idle, int cpu);

extern cpumask_t nohz_cpu_mask;

extern void show_state(void);
extern void show_regs(struct pt_regs *);






extern void show_stack(struct task_struct *task, unsigned long *sp);

void io_schedule(void);
long io_schedule_timeout(long timeout);

extern void cpu_init (void);
extern void trap_init(void);
extern void update_process_times(int user);
extern void scheduler_tick(int user_tick, int system);
extern unsigned long cache_decay_ticks;




extern int in_sched_functions(unsigned long addr);


extern signed long schedule_timeout(signed long timeout);
 void schedule(void);

struct namespace;




extern int sysctl_max_map_count;

# 1 "include/linux/aio.h" 1




# 1 "include/linux/workqueue.h" 1
# 12 "include/linux/workqueue.h"
struct workqueue_struct;

struct work_struct {
        unsigned long pending;
        struct list_head entry;
        void (*func)(void *);
        void *data;
        void *wq_data;
        struct timer_list timer;
};
# 53 "include/linux/workqueue.h"
extern struct workqueue_struct *__create_workqueue(const char *name,
                                                    int singlethread);



extern void destroy_workqueue(struct workqueue_struct *wq);

extern int queue_work(struct workqueue_struct *wq, struct work_struct *work);
extern int queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay);
extern void flush_workqueue(struct workqueue_struct *wq);

extern int schedule_work(struct work_struct *work);
extern int schedule_delayed_work(struct work_struct *work, unsigned long delay);

extern int schedule_delayed_work_on(int cpu, struct work_struct *work, unsigned long delay);
extern void flush_scheduled_work(void);
extern int current_is_keventd(void);
extern int keventd_up(void);

extern void init_workqueues(void);






static inline __attribute__((always_inline)) int cancel_delayed_work(struct work_struct *work)
{
        int ret;

        ret = del_timer_sync(&work->timer);
        if (ret)
                clear_bit(0, &work->pending);
        return ret;
}
# 6 "include/linux/aio.h" 2
# 1 "include/linux/aio_abi.h" 1
# 32 "include/linux/aio_abi.h"
typedef unsigned long aio_context_t;

enum {
        IOCB_CMD_PREAD = 0,
        IOCB_CMD_PWRITE = 1,
        IOCB_CMD_FSYNC = 2,
        IOCB_CMD_FDSYNC = 3,




        IOCB_CMD_NOOP = 6,
};


struct io_event {
        __u64 data;
        __u64 obj;
        __s64 res;
        __s64 res2;
};
# 68 "include/linux/aio_abi.h"
struct iocb {

        __u64 aio_data;
        __u32 aio_key, aio_reserved1;



        __u16 aio_lio_opcode;
        __s16 aio_reqprio;
        __u32 aio_fildes;

        __u64 aio_buf;
        __u64 aio_nbytes;
        __s64 aio_offset;


        __u64 aio_reserved2;
        __u64 aio_reserved3;
};
# 7 "include/linux/aio.h" 2






struct kioctx;
# 46 "include/linux/aio.h"
struct kiocb {
        struct list_head ki_run_list;
        long ki_flags;
        int ki_users;
        unsigned ki_key;

        struct file *ki_filp;
        struct kioctx *ki_ctx;
        int (*ki_cancel)(struct kiocb *, struct io_event *);
        ssize_t (*ki_retry)(struct kiocb *);
        void (*ki_dtor)(struct kiocb *);

        struct list_head ki_list;


        union {
                void *user;
                struct task_struct *tsk;
        } ki_obj;
        __u64 ki_user_data;
        loff_t ki_pos;

        unsigned short ki_opcode;
        size_t ki_nbytes;
        char *ki_buf;
        size_t ki_left;
        wait_queue_t ki_wait;
        long ki_retried;
        long ki_kicked;
        long ki_queued;

        void *private;
};
# 99 "include/linux/aio.h"
struct aio_ring {
        unsigned id;
        unsigned nr;
        unsigned head;
        unsigned tail;

        unsigned magic;
        unsigned compat_features;
        unsigned incompat_features;
        unsigned header_length;


        struct io_event io_events[0];
};




struct aio_ring_info {
        unsigned long mmap_base;
        unsigned long mmap_size;

        struct page **ring_pages;
        spinlock_t ring_lock;
        long nr_pages;

        unsigned nr, tail;

        struct page *internal_pages[8];
};

struct kioctx {
        atomic_t users;
        int dead;
        struct mm_struct *mm;


        unsigned long user_id;
        struct kioctx *next;

        wait_queue_head_t wait;

        spinlock_t ctx_lock;

        int reqs_active;
        struct list_head active_reqs;
        struct list_head run_list;

        unsigned max_reqs;

        struct aio_ring_info ring_info;

        struct work_struct wq;
};


extern unsigned aio_max_size;

extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb);
extern int aio_put_req(struct kiocb *iocb);
extern void kick_iocb(struct kiocb *iocb);
extern int aio_complete(struct kiocb *iocb, long res, long res2);
extern void __put_ioctx(struct kioctx *ctx);
struct mm_struct;
extern void exit_aio(struct mm_struct *mm);
extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
extern int io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, struct iocb *iocb);



struct kioctx *lookup_ioctx(unsigned long ctx_id);
int io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, struct iocb *iocb);
# 192 "include/linux/aio.h"
static inline __attribute__((always_inline)) struct kiocb *list_kiocb(struct list_head *h)
{
        return ({ const typeof( ((struct kiocb *)0)->ki_list ) *__mptr = (h); (struct kiocb *)( (char *)__mptr - ((size_t) &((struct kiocb *)0)->ki_list) );});
}


extern atomic_t aio_nr;
extern unsigned aio_max_nr;
# 191 "include/linux/sched.h" 2

extern unsigned long
arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
                       unsigned long, unsigned long);
extern unsigned long
arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
                          unsigned long len, unsigned long pgoff,
                          unsigned long flags);
extern void arch_unmap_area(struct vm_area_struct *area);
extern void arch_unmap_area_topdown(struct vm_area_struct *area);


struct mm_struct {
        struct vm_area_struct * mmap;
        struct rb_root mm_rb;
        struct vm_area_struct * mmap_cache;
        unsigned long (*get_unmapped_area) (struct file *filp,
                                unsigned long addr, unsigned long len,
                                unsigned long pgoff, unsigned long flags);
        void (*unmap_area) (struct vm_area_struct *area);
        unsigned long mmap_base;
        unsigned long free_area_cache;
        pgd_t * pgd;
        atomic_t mm_users;
        atomic_t mm_count;
        int map_count;
        struct rw_semaphore mmap_sem;
        spinlock_t page_table_lock;

        struct list_head mmlist;




        unsigned long start_code, end_code, start_data, end_data;
        unsigned long start_brk, brk, start_stack;
        unsigned long arg_start, arg_end, env_start, env_end;
        unsigned long rss, total_vm, locked_vm, shared_vm;
        unsigned long exec_vm, stack_vm, reserved_vm, def_flags;

        unsigned long saved_auxv[42];

        unsigned dumpable:1;
        cpumask_t cpu_vm_mask;


        mm_context_t context;


        unsigned long swap_token_time;
        char recent_pagein;


        int core_waiters;
        struct completion *core_startup_done, core_done;


        rwlock_t ioctx_list_lock;
        struct kioctx *ioctx_list;

        struct kioctx default_kioctx;
};

extern int mmlist_nr;

struct sighand_struct {
        atomic_t count;
        struct k_sigaction action[64];
        spinlock_t siglock;
};
# 269 "include/linux/sched.h"
struct signal_struct {
        atomic_t count;


        task_t *curr_target;


        struct sigpending shared_pending;


        int group_exit;
        int group_exit_code;





        struct task_struct *group_exit_task;
        int notify_count;


        int group_stop_count;

        int stop_state;


        struct list_head posix_timers;


        pid_t pgrp;
        pid_t tty_old_pgrp;
        pid_t session;

        int leader;

        struct tty_struct *tty;







        unsigned long utime, stime, cutime, cstime;
        unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
        unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
};
# 340 "include/linux/sched.h"
struct user_struct {
        atomic_t __count;
        atomic_t processes;
        atomic_t files;
        atomic_t sigpending;

        unsigned long mq_bytes;
        unsigned long locked_shm;


        struct list_head uidhash_list;
        uid_t uid;
};

extern struct user_struct *find_user(uid_t);

extern struct user_struct root_user;


typedef struct prio_array prio_array_t;
struct backing_dev_info;
struct reclaim_state;


struct k_itimer {
        struct list_head list;
        spinlock_t it_lock;
        clockid_t it_clock;
        timer_t it_id;
        int it_overrun;
        int it_overrun_last;
        int it_requeue_pending;
        int it_sigev_notify;
        int it_sigev_signo;
        sigval_t it_sigev_value;
        unsigned long it_incr;
        struct task_struct *it_process;
        struct timer_list it_timer;
        struct sigqueue *sigq;
        struct list_head abs_timer_entry;
        struct timespec wall_to_prev;
};
# 398 "include/linux/sched.h"
struct io_context;
void exit_io_context(void);



struct group_info {
        int ngroups;
        atomic_t usage;
        gid_t small_block[32];
        int nblocks;
        gid_t *blocks[0];
};
# 426 "include/linux/sched.h"
struct group_info *groups_alloc(int gidsetsize);
void groups_free(struct group_info *group_info);
int set_current_groups(struct group_info *group_info);





struct audit_context;
struct mempolicy;

struct task_struct {
        volatile long state;
        struct thread_info *thread_info;
        atomic_t usage;
        unsigned long flags;
        unsigned long ptrace;

        int lock_depth;

        int prio, static_prio;
        struct list_head run_list;
        prio_array_t *array;

        unsigned long sleep_avg;
        long interactive_credit;
        unsigned long long timestamp, last_ran;
        int activated;

        unsigned long policy;
        cpumask_t cpus_allowed;
        unsigned int time_slice, first_time_slice;





        struct list_head tasks;




        struct list_head ptrace_children;
        struct list_head ptrace_list;

        struct mm_struct *mm, *active_mm;


        struct linux_binfmt *binfmt;
        int exit_code, exit_signal;
        int pdeath_signal;

        unsigned long personality;
        unsigned did_exec:1;
        pid_t pid;
        pid_t tgid;





        struct task_struct *real_parent;
        struct task_struct *parent;




        struct list_head children;
        struct list_head sibling;
        struct task_struct *group_leader;


        struct pid pids[PIDTYPE_MAX];

        wait_queue_head_t wait_chldexit;
        struct completion *vfork_done;
        int *set_child_tid;
        int *clear_child_tid;

        unsigned long rt_priority;
        unsigned long it_real_value, it_prof_value, it_virt_value;
        unsigned long it_real_incr, it_prof_incr, it_virt_incr;
        struct timer_list real_timer;
        unsigned long utime, stime;
        unsigned long nvcsw, nivcsw;
        struct timespec start_time;

        unsigned long min_flt, maj_flt;

        uid_t uid,euid,suid,fsuid;
        gid_t gid,egid,sgid,fsgid;
        struct group_info *group_info;
        kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
        unsigned keep_capabilities:1;
        struct user_struct *user;

        struct rlimit rlim[13];
        unsigned short used_math;
        char comm[16];

        int link_count, total_link_count;

        struct sysv_sem sysvsem;

        struct thread_struct thread;

        struct fs_struct *fs;

        struct files_struct *files;

        struct namespace *namespace;

        struct signal_struct *signal;
        struct sighand_struct *sighand;

        sigset_t blocked, real_blocked;
        struct sigpending pending;

        unsigned long sas_ss_sp;
        size_t sas_ss_size;
        int (*notifier)(void *priv);
        void *notifier_data;
        sigset_t *notifier_mask;

        void *security;
        struct audit_context *audit_context;


        u32 parent_exec_id;
        u32 self_exec_id;

        spinlock_t alloc_lock;

        spinlock_t proc_lock;

        spinlock_t switch_lock;


        void *journal_info;


        struct reclaim_state *reclaim_state;

        struct dentry *proc_dentry;
        struct backing_dev_info *backing_dev_info;

        struct io_context *io_context;

        unsigned long ptrace_message;
        siginfo_t *last_siginfo;






        wait_queue_t *io_wait;

        struct mempolicy *mempolicy;
        short il_next;

};

static inline __attribute__((always_inline)) pid_t process_group(struct task_struct *tsk)
{
        return tsk->signal->pgrp;
}

extern void free_task(struct task_struct *tsk);
extern void __put_task_struct(struct task_struct *tsk);
# 626 "include/linux/sched.h"
extern int set_cpus_allowed(task_t *p, cpumask_t new_mask);







extern unsigned long long sched_clock(void);



extern void sched_exec(void);




extern void sched_idle_next(void);
extern void set_user_nice(task_t *p, long nice);
extern int task_prio(const task_t *p);
extern int task_nice(const task_t *p);
extern int task_curr(const task_t *p);
extern int idle_cpu(int cpu);

void yield(void);




extern struct exec_domain default_exec_domain;

union thread_union {
        struct thread_info thread_info;
        unsigned long stack[(1UL << (12 + 1))/sizeof(long)];
};


static inline __attribute__((always_inline)) int kstack_end(void *addr)
{



        return !(((unsigned long)addr+sizeof(void*)-1) & ((1UL << (12 + 1))-sizeof(void*)));
}


extern union thread_union init_thread_union;
extern struct task_struct init_task;

extern struct mm_struct init_mm;


extern struct task_struct *find_task_by_pid_type(int type, int pid);
extern void set_special_pids(pid_t session, pid_t pgrp);
extern void __set_special_pids(pid_t session, pid_t pgrp);


extern struct user_struct * alloc_uid(uid_t);
static inline __attribute__((always_inline)) struct user_struct *get_uid(struct user_struct *u)
{
        atomic_inc(&u->__count);
        return u;
}
extern void free_uid(struct user_struct *);
extern void switch_uid(struct user_struct *);



extern unsigned long itimer_ticks;
extern unsigned long itimer_next;
extern void do_timer(struct pt_regs *);

extern int wake_up_state(struct task_struct * tsk, unsigned int state);
extern int wake_up_process(struct task_struct * tsk);
extern void wake_up_new_task(struct task_struct * tsk, unsigned long clone_flags);


 extern void kick_process(struct task_struct *tsk);



extern void sched_fork(task_t * p);
extern void sched_exit(task_t * p);

extern int in_group_p(gid_t);
extern int in_egroup_p(gid_t);

extern void proc_caches_init(void);
extern void flush_signals(struct task_struct *);
extern void flush_signal_handlers(struct task_struct *, int force_default);
extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);

static inline __attribute__((always_inline)) int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
        unsigned long flags;
        int ret;

        flags = _spin_lock_irqsave(&tsk->sighand->siglock);
        ret = dequeue_signal(tsk, mask, info);
        _spin_unlock_irqrestore(&tsk->sighand->siglock, flags);

        return ret;
}

extern void block_all_signals(int (*notifier)(void *priv), void *priv,
                              sigset_t *mask);
extern void unblock_all_signals(void);
extern void release_task(struct task_struct * p);
extern int send_sig_info(int, struct siginfo *, struct task_struct *);
extern int send_group_sig_info(int, struct siginfo *, struct task_struct *);
extern int force_sigsegv(int, struct task_struct *);
extern int force_sig_info(int, struct siginfo *, struct task_struct *);
extern int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp);
extern int kill_pg_info(int, struct siginfo *, pid_t);
extern int kill_sl_info(int, struct siginfo *, pid_t);
extern int kill_proc_info(int, struct siginfo *, pid_t);
extern void do_notify_parent(struct task_struct *, int);
extern void force_sig(int, struct task_struct *);
extern void force_sig_specific(int, struct task_struct *);
extern int send_sig(int, struct task_struct *, int);
extern void zap_other_threads(struct task_struct *p);
extern int kill_pg(pid_t, int, int);
extern int kill_sl(pid_t, int, int);
extern int kill_proc(pid_t, int, int);
extern struct sigqueue *sigqueue_alloc(void);
extern void sigqueue_free(struct sigqueue *);
extern int send_sigqueue(int, struct sigqueue *, struct task_struct *);
extern int send_group_sigqueue(int, struct sigqueue *, struct task_struct *);
extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);
# 764 "include/linux/sched.h"
static inline __attribute__((always_inline)) int on_sig_stack(unsigned long sp)
{
        return (sp - get_current()->sas_ss_sp < get_current()->sas_ss_size);
}

static inline __attribute__((always_inline)) int sas_ss_flags(unsigned long sp)
{
        return (get_current()->sas_ss_size == 0 ? 2
                : on_sig_stack(sp) ? 1 : 0);
}






static inline __attribute__((always_inline)) int capable(int cap)
{
        if (((get_current()->cap_effective) & (1 << (cap)))) {
                get_current()->flags |= 0x00000100;
                return 1;
        }
        return 0;
}





extern struct mm_struct * mm_alloc(void);


extern void __mmdrop(struct mm_struct *);
static inline __attribute__((always_inline)) void mmdrop(struct mm_struct * mm)
{
        if (atomic_dec_and_test(&mm->mm_count))
                __mmdrop(mm);
}


extern void mmput(struct mm_struct *);

extern struct mm_struct *get_task_mm(struct task_struct *task);

extern void mm_release(struct task_struct *, struct mm_struct *);

extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
extern void flush_thread(void);
extern void exit_thread(void);

extern void exit_mm(struct task_struct *);
extern void exit_files(struct task_struct *);
extern void exit_signal(struct task_struct *);
extern void __exit_signal(struct task_struct *);
extern void exit_sighand(struct task_struct *);
extern void __exit_sighand(struct task_struct *);
extern void exit_itimers(struct signal_struct *);

extern void do_group_exit(int);

extern void reparent_to_init(void);
extern void daemonize(const char *, ...);
extern int allow_signal(int);
extern int disallow_signal(int);
extern task_t *child_reaper;

extern int do_execve(char *, char * *, char * *, struct pt_regs *);
extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int *, int *);
task_t *fork_idle(int);

extern void set_task_comm(struct task_struct *tsk, char *from);
extern void get_task_comm(char *to, struct task_struct *tsk);


extern void wait_task_inactive(task_t * p);
# 874 "include/linux/sched.h"
extern task_t * next_thread(const task_t *p);



static inline __attribute__((always_inline)) int thread_group_empty(task_t *p)
{
        return list_empty(&p->pids[PIDTYPE_TGID].pid_list);
}




extern void unhash_process(struct task_struct *p);
# 896 "include/linux/sched.h"
static inline __attribute__((always_inline)) void task_lock(struct task_struct *p)
{
        _spin_lock(&p->alloc_lock);
}

static inline __attribute__((always_inline)) void task_unlock(struct task_struct *p)
{
        _spin_unlock(&p->alloc_lock);
}




static inline __attribute__((always_inline)) void set_tsk_thread_flag(struct task_struct *tsk, int flag)
{
        set_ti_thread_flag(tsk->thread_info,flag);
}

static inline __attribute__((always_inline)) void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
{
        clear_ti_thread_flag(tsk->thread_info,flag);
}

static inline __attribute__((always_inline)) int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
{
        return test_and_set_ti_thread_flag(tsk->thread_info,flag);
}

static inline __attribute__((always_inline)) int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
{
        return test_and_clear_ti_thread_flag(tsk->thread_info,flag);
}

static inline __attribute__((always_inline)) int test_tsk_thread_flag(struct task_struct *tsk, int flag)
{
        return test_ti_thread_flag(tsk->thread_info,flag);
}

static inline __attribute__((always_inline)) void set_tsk_need_resched(struct task_struct *tsk)
{
        set_tsk_thread_flag(tsk,3);
}

static inline __attribute__((always_inline)) void clear_tsk_need_resched(struct task_struct *tsk)
{
        clear_tsk_thread_flag(tsk,3);
}

static inline __attribute__((always_inline)) int signal_pending(struct task_struct *p)
{
        return __builtin_expect(!!(test_tsk_thread_flag(p,2)), 0);
}

static inline __attribute__((always_inline)) int need_resched(void)
{
        return __builtin_expect(!!(test_thread_flag(3)), 0);
}

extern void __cond_resched(void);
static inline __attribute__((always_inline)) void cond_resched(void)
{
        if (need_resched())
                __cond_resched();
}
# 969 "include/linux/sched.h"
static inline __attribute__((always_inline)) void cond_resched_lock(spinlock_t * lock)
{
        if (need_resched()) {
                _raw_spin_unlock(lock);
                do { } while (0);
                __cond_resched();
                _spin_lock(lock);
        }
}





extern void recalc_sigpending_tsk(struct task_struct *t);
extern void recalc_sigpending(void);

extern void signal_wake_up(struct task_struct *t, int resume_stopped);






static inline __attribute__((always_inline)) unsigned int task_cpu(const struct task_struct *p)
{
        return p->thread_info->cpu;
}

static inline __attribute__((always_inline)) void set_task_cpu(struct task_struct *p, unsigned int cpu)
{
        p->thread_info->cpu = cpu;
}
# 1019 "include/linux/sched.h"
static inline __attribute__((always_inline)) void arch_pick_mmap_layout(struct mm_struct *mm)
{
        mm->mmap_base = (test_thread_flag(17) ? (((((get_current()->personality & ADDR_LIMIT_3GB) ? 0xc0000000 : 0xFFFFe000)/3)+(1UL << 12)-1)&(~((1UL << 12)-1))) : ((((0x0000007fc0000000UL)/3)+(1UL << 12)-1)&(~((1UL << 12)-1))));
        mm->get_unmapped_area = arch_get_unmapped_area;
        mm->unmap_area = arch_unmap_area;
}


extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
# 11 "include/linux/module.h" 2


# 1 "include/linux/stat.h" 1





# 1 "include/asm/stat.h" 1





struct stat {
        unsigned long st_dev;
        unsigned long st_ino;
        unsigned long st_nlink;

        unsigned int st_mode;
        unsigned int st_uid;
        unsigned int st_gid;
        unsigned int __pad0;
        unsigned long st_rdev;
        long st_size;
        long st_blksize;
        long st_blocks;

        unsigned long st_atime;
        unsigned long st_atime_nsec;
        unsigned long st_mtime;
        unsigned long st_mtime_nsec;
        unsigned long st_ctime;
        unsigned long st_ctime_nsec;
        long __unused[3];
};


struct __old_kernel_stat {
        unsigned short st_dev;
        unsigned short st_ino;
        unsigned short st_mode;
        unsigned short st_nlink;
        unsigned short st_uid;
        unsigned short st_gid;
        unsigned short st_rdev;
        unsigned int st_size;
        unsigned int st_atime;
        unsigned int st_mtime;
        unsigned int st_ctime;
};
# 7 "include/linux/stat.h" 2
# 59 "include/linux/stat.h"
struct kstat {
        unsigned long ino;
        dev_t dev;
        umode_t mode;
        unsigned int nlink;
        uid_t uid;
        gid_t gid;
        dev_t rdev;
        loff_t size;
        struct timespec atime;
        struct timespec mtime;
        struct timespec ctime;
        unsigned long blksize;
        unsigned long blocks;
};
# 14 "include/linux/module.h" 2


# 1 "include/linux/kmod.h" 1
# 33 "include/linux/kmod.h"
static inline __attribute__((always_inline)) int request_module(const char * name, ...) { return -38; }



extern int call_usermodehelper(char *path, char *argv[], char *envp[], int wait);
extern void usermodehelper_init(void);
# 17 "include/linux/module.h" 2
# 1 "include/linux/elf.h" 1




# 1 "include/asm/elf.h" 1
# 9 "include/asm/elf.h"
# 1 "include/asm/user.h" 1
# 50 "include/asm/user.h"
struct user_i387_struct {
        unsigned short cwd;
        unsigned short swd;
        unsigned short twd;
        unsigned short fop;
        __u64 rip;
        __u64 rdp;
        __u32 mxcsr;
        __u32 mxcsr_mask;
        __u32 st_space[32];
        __u32 xmm_space[64];
        __u32 padding[24];
};




struct user_regs_struct {
        unsigned long r15,r14,r13,r12,rbp,rbx,r11,r10;
        unsigned long r9,r8,rax,rcx,rdx,rsi,rdi,orig_rax;
        unsigned long rip,cs,eflags;
        unsigned long rsp,ss;
        unsigned long fs_base, gs_base;
        unsigned long ds,es,fs,gs;
};




struct user{


  struct user_regs_struct regs;

  int u_fpvalid;

  int pad0;
  struct user_i387_struct i387;

  unsigned long int u_tsize;
  unsigned long int u_dsize;
  unsigned long int u_ssize;
  unsigned long start_code;
  unsigned long start_stack;



  long int signal;
  int reserved;
  int pad1;
  struct user_pt_regs * u_ar0;

  struct user_i387_struct* u_fpstate;
  unsigned long magic;
  char u_comm[32];
  unsigned long u_debugreg[8];
  unsigned long error_code;
  unsigned long fault_address;
};
# 10 "include/asm/elf.h" 2
# 33 "include/asm/elf.h"
typedef unsigned long elf_greg_t;


typedef elf_greg_t elf_gregset_t[(sizeof (struct user_regs_struct) / sizeof(elf_greg_t))];

typedef struct user_i387_struct elf_fpregset_t;
# 144 "include/asm/elf.h"
extern void set_personality_64bit(void);
# 154 "include/asm/elf.h"
extern int dump_task_regs (struct task_struct *, elf_gregset_t *);
extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
# 6 "include/linux/elf.h" 2
# 15 "include/linux/elf.h"
typedef __u32 Elf32_Addr;
typedef __u16 Elf32_Half;
typedef __u32 Elf32_Off;
typedef __s32 Elf32_Sword;
typedef __u32 Elf32_Word;


typedef __u64 Elf64_Addr;
typedef __u16 Elf64_Half;
typedef __s16 Elf64_SHalf;
typedef __u64 Elf64_Off;
typedef __s32 Elf64_Sword;
typedef __u32 Elf64_Word;
typedef __u64 Elf64_Xword;
typedef __s64 Elf64_Sxword;
# 181 "include/linux/elf.h"
typedef struct dynamic{
  Elf32_Sword d_tag;
  union{
    Elf32_Sword d_val;
    Elf32_Addr d_ptr;
  } d_un;
} Elf32_Dyn;

typedef struct {
  Elf64_Sxword d_tag;
  union {
    Elf64_Xword d_val;
    Elf64_Addr d_ptr;
  } d_un;
} Elf64_Dyn;
# 204 "include/linux/elf.h"
typedef struct elf32_rel {
  Elf32_Addr r_offset;
  Elf32_Word r_info;
} Elf32_Rel;

typedef struct elf64_rel {
  Elf64_Addr r_offset;
  Elf64_Xword r_info;
} Elf64_Rel;

typedef struct elf32_rela{
  Elf32_Addr r_offset;
  Elf32_Word r_info;
  Elf32_Sword r_addend;
} Elf32_Rela;

typedef struct elf64_rela {
  Elf64_Addr r_offset;
  Elf64_Xword r_info;
  Elf64_Sxword r_addend;
} Elf64_Rela;

typedef struct elf32_sym{
  Elf32_Word st_name;
  Elf32_Addr st_value;
  Elf32_Word st_size;
  unsigned char st_info;
  unsigned char st_other;
  Elf32_Half st_shndx;
} Elf32_Sym;

typedef struct elf64_sym {
  Elf64_Word st_name;
  unsigned char st_info;
  unsigned char st_other;
  Elf64_Half st_shndx;
  Elf64_Addr st_value;
  Elf64_Xword st_size;
} Elf64_Sym;




typedef struct elf32_hdr{
  unsigned char e_ident[16];
  Elf32_Half e_type;
  Elf32_Half e_machine;
  Elf32_Word e_version;
  Elf32_Addr e_entry;
  Elf32_Off e_phoff;
  Elf32_Off e_shoff;
  Elf32_Word e_flags;
  Elf32_Half e_ehsize;
  Elf32_Half e_phentsize;
  Elf32_Half e_phnum;
  Elf32_Half e_shentsize;
  Elf32_Half e_shnum;
  Elf32_Half e_shstrndx;
} Elf32_Ehdr;

typedef struct elf64_hdr {
  unsigned char e_ident[16];
  Elf64_Half e_type;
  Elf64_Half e_machine;
  Elf64_Word e_version;
  Elf64_Addr e_entry;
  Elf64_Off e_phoff;
  Elf64_Off e_shoff;
  Elf64_Word e_flags;
  Elf64_Half e_ehsize;
  Elf64_Half e_phentsize;
  Elf64_Half e_phnum;
  Elf64_Half e_shentsize;
  Elf64_Half e_shnum;
  Elf64_Half e_shstrndx;
} Elf64_Ehdr;







typedef struct elf32_phdr{
  Elf32_Word p_type;
  Elf32_Off p_offset;
  Elf32_Addr p_vaddr;
  Elf32_Addr p_paddr;
  Elf32_Word p_filesz;
  Elf32_Word p_memsz;
  Elf32_Word p_flags;
  Elf32_Word p_align;
} Elf32_Phdr;

typedef struct elf64_phdr {
  Elf64_Word p_type;
  Elf64_Word p_flags;
  Elf64_Off p_offset;
  Elf64_Addr p_vaddr;
  Elf64_Addr p_paddr;
  Elf64_Xword p_filesz;
  Elf64_Xword p_memsz;
  Elf64_Xword p_align;
} Elf64_Phdr;
# 343 "include/linux/elf.h"
typedef struct {
  Elf32_Word sh_name;
  Elf32_Word sh_type;
  Elf32_Word sh_flags;
  Elf32_Addr sh_addr;
  Elf32_Off sh_offset;
  Elf32_Word sh_size;
  Elf32_Word sh_link;
  Elf32_Word sh_info;
  Elf32_Word sh_addralign;
  Elf32_Word sh_entsize;
} Elf32_Shdr;

typedef struct elf64_shdr {
  Elf64_Word sh_name;
  Elf64_Word sh_type;
  Elf64_Xword sh_flags;
  Elf64_Addr sh_addr;
  Elf64_Off sh_offset;
  Elf64_Xword sh_size;
  Elf64_Word sh_link;
  Elf64_Word sh_info;
  Elf64_Xword sh_addralign;
  Elf64_Xword sh_entsize;
} Elf64_Shdr;
# 416 "include/linux/elf.h"
typedef struct elf32_note {
  Elf32_Word n_namesz;
  Elf32_Word n_descsz;
  Elf32_Word n_type;
} Elf32_Nhdr;


typedef struct elf64_note {
  Elf64_Word n_namesz;
  Elf64_Word n_descsz;
  Elf64_Word n_type;
} Elf64_Nhdr;
# 438 "include/linux/elf.h"
extern Elf64_Dyn _DYNAMIC [];
# 18 "include/linux/module.h" 2

# 1 "include/linux/kobject.h" 1
# 22 "include/linux/kobject.h"
# 1 "include/linux/sysfs.h" 1
# 12 "include/linux/sysfs.h"
struct kobject;
struct module;

struct attribute {
        char * name;
        struct module * owner;
        mode_t mode;
};

struct attribute_group {
        char * name;
        struct attribute ** attrs;
};
# 48 "include/linux/sysfs.h"
struct bin_attribute {
        struct attribute attr;
        size_t size;
        ssize_t (*read)(struct kobject *, char *, loff_t, size_t);
        ssize_t (*write)(struct kobject *, char *, loff_t, size_t);
};

struct sysfs_ops {
        ssize_t (*show)(struct kobject *, struct attribute *,char *);
        ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
};



extern int
sysfs_create_dir(struct kobject *);

extern void
sysfs_remove_dir(struct kobject *);

extern int
sysfs_rename_dir(struct kobject *, const char *new_name);

extern int
sysfs_create_file(struct kobject *, const struct attribute *);

extern int
sysfs_update_file(struct kobject *, const struct attribute *);

extern void
sysfs_remove_file(struct kobject *, const struct attribute *);

extern int
sysfs_create_link(struct kobject * kobj, struct kobject * target, char * name);

extern void
sysfs_remove_link(struct kobject *, char * name);

int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr);
int sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr);

int sysfs_create_group(struct kobject *, const struct attribute_group *);
void sysfs_remove_group(struct kobject *, const struct attribute_group *);
# 23 "include/linux/kobject.h" 2

# 1 "include/linux/kref.h" 1
# 23 "include/linux/kref.h"
struct kref {
        atomic_t refcount;
};

void kref_init(struct kref *kref);
void kref_get(struct kref *kref);
void kref_put(struct kref *kref, void (*release) (struct kref *kref));
# 25 "include/linux/kobject.h" 2




struct kobject {
        char * k_name;
        char name[20];
        struct kref kref;
        struct list_head entry;
        struct kobject * parent;
        struct kset * kset;
        struct kobj_type * ktype;
        struct dentry * dentry;
};

extern int kobject_set_name(struct kobject *, const char *, ...)
        __attribute__((format(printf,2,3)));

static inline __attribute__((always_inline)) char * kobject_name(struct kobject * kobj)
{
        return kobj->k_name;
}

extern void kobject_init(struct kobject *);
extern void kobject_cleanup(struct kobject *);

extern int kobject_add(struct kobject *);
extern void kobject_del(struct kobject *);

extern int kobject_rename(struct kobject *, char *new_name);

extern int kobject_register(struct kobject *);
extern void kobject_unregister(struct kobject *);

extern struct kobject * kobject_get(struct kobject *);
extern void kobject_put(struct kobject *);

extern void kobject_hotplug(const char *action, struct kobject *);

extern char * kobject_get_path(struct kset *, struct kobject *, int);

struct kobj_type {
        void (*release)(struct kobject *);
        struct sysfs_ops * sysfs_ops;
        struct attribute ** default_attrs;
};
# 91 "include/linux/kobject.h"
struct kset_hotplug_ops {
        int (*filter)(struct kset *kset, struct kobject *kobj);
        char *(*name)(struct kset *kset, struct kobject *kobj);
        int (*hotplug)(struct kset *kset, struct kobject *kobj, char **envp,
                        int num_envp, char *buffer, int buffer_size);
};

struct kset {
        struct subsystem * subsys;
        struct kobj_type * ktype;
        struct list_head list;
        struct kobject kobj;
        struct kset_hotplug_ops * hotplug_ops;
};


extern void kset_init(struct kset * k);
extern int kset_add(struct kset * k);
extern int kset_register(struct kset * k);
extern void kset_unregister(struct kset * k);

static inline __attribute__((always_inline)) struct kset * to_kset(struct kobject * kobj)
{
        return kobj ? ({ const typeof( ((struct kset *)0)->kobj ) *__mptr = (kobj); (struct kset *)( (char *)__mptr - ((size_t) &((struct kset *)0)->kobj) );}) : ((void *)0);
}

static inline __attribute__((always_inline)) struct kset * kset_get(struct kset * k)
{
        return k ? to_kset(kobject_get(&k->kobj)) : ((void *)0);
}

static inline __attribute__((always_inline)) void kset_put(struct kset * k)
{
        kobject_put(&k->kobj);
}

static inline __attribute__((always_inline)) struct kobj_type * get_ktype(struct kobject * k)
{
        if (k->kset && k->kset->ktype)
                return k->kset->ktype;
        else
                return k->ktype;
}

extern struct kobject * kset_find_obj(struct kset *, const char *);
# 146 "include/linux/kobject.h"
struct subsystem {
        struct kset kset;
        struct rw_semaphore rwsem;
};
# 214 "include/linux/kobject.h"
extern void subsystem_init(struct subsystem *);
extern int subsystem_register(struct subsystem *);
extern void subsystem_unregister(struct subsystem *);

static inline __attribute__((always_inline)) struct subsystem * subsys_get(struct subsystem * s)
{
        return s ? ({ const typeof( ((struct subsystem *)0)->kset ) *__mptr = (kset_get(&s->kset)); (struct subsystem *)( (char *)__mptr - ((size_t) &((struct subsystem *)0)->kset) );}) : ((void *)0);
}

static inline __attribute__((always_inline)) void subsys_put(struct subsystem * s)
{
        kset_put(&s->kset);
}

struct subsys_attribute {
        struct attribute attr;
        ssize_t (*show)(struct subsystem *, char *);
        ssize_t (*store)(struct subsystem *, const char *, size_t);
};

extern int subsys_create_file(struct subsystem * , struct subsys_attribute *);
extern void subsys_remove_file(struct subsystem * , struct subsys_attribute *);
# 20 "include/linux/module.h" 2
# 1 "include/linux/moduleparam.h" 1
# 16 "include/linux/moduleparam.h"
struct kernel_param;


typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);

typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);

struct kernel_param {
        const char *name;
        unsigned int perm;
        param_set_fn set;
        param_get_fn get;
        void *arg;
};


struct kparam_string {
        unsigned int maxlen;
        char *string;
};


struct kparam_array
{
        unsigned int max;
        unsigned int *num;
        param_set_fn set;
        param_get_fn get;
        unsigned int elemsize;
        void *elem;
};
# 80 "include/linux/moduleparam.h"
extern int parse_args(const char *name,
                      char *args,
                      struct kernel_param *params,
                      unsigned num,
                      int (*unknown)(char *param, char *val));







extern int param_set_byte(const char *val, struct kernel_param *kp);
extern int param_get_byte(char *buffer, struct kernel_param *kp);


extern int param_set_short(const char *val, struct kernel_param *kp);
extern int param_get_short(char *buffer, struct kernel_param *kp);


extern int param_set_ushort(const char *val, struct kernel_param *kp);
extern int param_get_ushort(char *buffer, struct kernel_param *kp);


extern int param_set_int(const char *val, struct kernel_param *kp);
extern int param_get_int(char *buffer, struct kernel_param *kp);


extern int param_set_uint(const char *val, struct kernel_param *kp);
extern int param_get_uint(char *buffer, struct kernel_param *kp);


extern int param_set_long(const char *val, struct kernel_param *kp);
extern int param_get_long(char *buffer, struct kernel_param *kp);


extern int param_set_ulong(const char *val, struct kernel_param *kp);
extern int param_get_ulong(char *buffer, struct kernel_param *kp);


extern int param_set_charp(const char *val, struct kernel_param *kp);
extern int param_get_charp(char *buffer, struct kernel_param *kp);


extern int param_set_bool(const char *val, struct kernel_param *kp);
extern int param_get_bool(char *buffer, struct kernel_param *kp);


extern int param_set_invbool(const char *val, struct kernel_param *kp);
extern int param_get_invbool(char *buffer, struct kernel_param *kp);
# 143 "include/linux/moduleparam.h"
extern int param_array_set(const char *val, struct kernel_param *kp);
extern int param_array_get(char *buffer, struct kernel_param *kp);

extern int param_set_copystring(const char *val, struct kernel_param *kp);
extern int param_get_string(char *buffer, struct kernel_param *kp);

int param_array(const char *name,
                const char *val,
                unsigned int min, unsigned int max,
                void *elem, int elemsize,
                int (*set)(const char *, struct kernel_param *kp),
                int *num);
# 21 "include/linux/module.h" 2
# 1 "include/asm/local.h" 1





typedef struct
{
        volatile unsigned int counter;
} local_t;






static __inline__ __attribute__((always_inline)) void local_inc(local_t *v)
{
        __asm__ __volatile__(
                "incl %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}

static __inline__ __attribute__((always_inline)) void local_dec(local_t *v)
{
        __asm__ __volatile__(
                "decl %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}

static __inline__ __attribute__((always_inline)) void local_add(unsigned long i, local_t *v)
{
        __asm__ __volatile__(
                "addl %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}

static __inline__ __attribute__((always_inline)) void local_sub(unsigned long i, local_t *v)
{
        __asm__ __volatile__(
                "subl %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}
# 22 "include/linux/module.h" 2

# 1 "include/asm/module.h" 1



struct mod_arch_specific {};
# 24 "include/linux/module.h" 2
# 35 "include/linux/module.h"
struct kernel_symbol
{
        unsigned long value;
        const char *name;
};

struct modversion_info
{
        unsigned long crc;
        char name[(64 - sizeof(unsigned long))];
};


extern int init_module(void);
extern void cleanup_module(void);


struct exception_table_entry;

const struct exception_table_entry *
search_extable(const struct exception_table_entry *first,
               const struct exception_table_entry *last,
               unsigned long value);
void sort_extable(struct exception_table_entry *start,
                  struct exception_table_entry *finish);
void sort_main_extable(void);
# 151 "include/linux/module.h"
const struct exception_table_entry *search_exception_tables(unsigned long add);

struct notifier_block;




void *__symbol_get(const char *symbol);
void *__symbol_get_gpl(const char *symbol);
# 199 "include/linux/module.h"
struct module_ref
{
        local_t count;
} __attribute__((__aligned__((1 << (7)))));

enum module_state
{
        MODULE_STATE_LIVE,
        MODULE_STATE_COMING,
        MODULE_STATE_GOING,
};


struct module_attribute
{
        struct attribute attr;
        struct kernel_param *param;
};

struct module_kobject
{

        struct kobject kobj;


        unsigned int num_attributes;
        struct module_attribute attr[0];
};



struct module_sect_attr
{
        struct attribute attr;
        char name[32];
        unsigned long address;
};

struct module_sections
{
        struct kobject kobj;
        struct module_sect_attr attrs[0];
};


struct module
{
        enum module_state state;


        struct list_head list;


        char name[(64 - sizeof(unsigned long))];


        struct module_kobject *mkobj;


        const struct kernel_symbol *syms;
        unsigned int num_syms;
        const unsigned long *crcs;


        const struct kernel_symbol *gpl_syms;
        unsigned int num_gpl_syms;
        const unsigned long *gpl_crcs;


        unsigned int num_exentries;
        const struct exception_table_entry *extable;


        int (*init)(void);


        void *module_init;


        void *module_core;


        unsigned long init_size, core_size;


        unsigned long init_text_size, core_text_size;


        struct mod_arch_specific arch;


        int unsafe;


        int license_gplok;



        struct module_ref ref[8];


        struct list_head modules_which_use_me;


        struct task_struct *waiter;


        void (*exit)(void);


        struct kernel_param refcnt_param;




        Elf64_Sym *symtab;
        unsigned long num_symtab;
        char *strtab;


        struct module_sections *sect_attrs;



        void *percpu;



        char *args;
};




static inline __attribute__((always_inline)) int module_is_live(struct module *mod)
{
        return mod->state != MODULE_STATE_GOING;
}


struct module *module_text_address(unsigned long addr);
struct module *__module_text_address(unsigned long addr);



struct module *module_get_kallsym(unsigned int symnum,
                                  unsigned long *value,
                                  char *type,
                                  char namebuf[128]);


unsigned long module_kallsyms_lookup_name(const char *name);

int is_exported(const char *name, const struct module *mod);

extern void __module_put_and_exit(struct module *mod, long code)
        __attribute__((noreturn));



unsigned int module_refcount(struct module *mod);
void __symbol_put(const char *symbol);

void symbol_put_addr(void *addr);



static inline __attribute__((always_inline)) void __module_get(struct module *module)
{
        if (module) {
                do { if (__builtin_expect(!!((module_refcount(module) == 0)!=0), 0)) asm volatile("ud2 ; .quad %c1 ; .short %c0" :: "i"(369), "i" ("radix_clear")); } while(0);
                local_inc(&module->ref[({ do { } while (0); ({ typedef typeof(((struct x8664_pda *)0)->cpunumber) T__; T__ ret__; switch ((sizeof(((struct x8664_pda *)0)->cpunumber))) { case 2: asm volatile("mov" "w %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break;case 4: asm volatile("mov" "l %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break;case 8: asm volatile("mov" "q %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break; default: __bad_pda_field(); } ret__; }); })].count);
                do { } while (0);
        }
}

static inline __attribute__((always_inline)) int try_module_get(struct module *module)
{
        int ret = 1;

        if (module) {
                unsigned int cpu = ({ do { } while (0); ({ typedef typeof(((struct x8664_pda *)0)->cpunumber) T__; T__ ret__; switch ((sizeof(((struct x8664_pda *)0)->cpunumber))) { case 2: asm volatile("mov" "w %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break;case 4: asm volatile("mov" "l %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break;case 8: asm volatile("mov" "q %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break; default: __bad_pda_field(); } ret__; }); });
                if (__builtin_expect(!!(module_is_live(module)), 1))
                        local_inc(&module->ref[cpu].count);
                else
                        ret = 0;
                do { } while (0);
        }
        return ret;
}

static inline __attribute__((always_inline)) void module_put(struct module *module)
{
        if (module) {
                unsigned int cpu = ({ do { } while (0); ({ typedef typeof(((struct x8664_pda *)0)->cpunumber) T__; T__ ret__; switch ((sizeof(((struct x8664_pda *)0)->cpunumber))) { case 2: asm volatile("mov" "w %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break;case 4: asm volatile("mov" "l %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break;case 8: asm volatile("mov" "q %%gs:%P1,%0":"=r" (ret__):"i"(((size_t) &((struct x8664_pda *)0)->cpunumber)):"memory"); break; default: __bad_pda_field(); } ret__; }); });
                local_dec(&module->ref[cpu].count);

                if (__builtin_expect(!!(!module_is_live(module)), 0))
                        wake_up_process(module->waiter);
                do { } while (0);
        }
}
# 436 "include/linux/module.h"
const char *module_address_lookup(unsigned long addr,
                                  unsigned long *symbolsize,
                                  unsigned long *offset,
                                  char **modname);


const struct exception_table_entry *search_module_extables(unsigned long addr);

int register_module_notifier(struct notifier_block * nb);
int unregister_module_notifier(struct notifier_block * nb);

extern void print_modules(void);
# 543 "include/linux/module.h"
struct obsolete_modparm {
        char name[64];
        char type[64-sizeof(void *)];
        void *addr;
};
# 583 "include/linux/module.h"
extern void inter_module_register(const char *, struct module *, const void *);
extern void inter_module_unregister(const char *);
extern const void *inter_module_get(const char *);
extern const void *inter_module_get_request(const char *, const char *);
extern void inter_module_put(const char *);
# 6 "lib/radix-clear.c" 2
# 1 "include/linux/radix-tree.h" 1
# 25 "include/linux/radix-tree.h"
struct radix_tree_root {
        unsigned int height;
        int gfp_mask;
        struct radix_tree_node *rnode;
};
# 47 "include/linux/radix-tree.h"
int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
void *radix_tree_delete(struct radix_tree_root *, unsigned long);
unsigned int
radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
                        unsigned long first_index, unsigned int max_items);
int radix_tree_preload(int gfp_mask);
void radix_tree_init(void);
void *radix_tree_tag_set(struct radix_tree_root *root,
                        unsigned long index, int tag);
void *radix_tree_tag_clear(struct radix_tree_root *root,
                        unsigned long index, int tag);
int radix_tree_tag_get(struct radix_tree_root *root,
                        unsigned long index, int tag);
unsigned int
radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
                unsigned long first_index, unsigned int max_items, int tag);
int radix_tree_tagged(struct radix_tree_root *root, int tag);

static inline __attribute__((always_inline)) void radix_tree_preload_end(void)
{
        do { } while (0);
}
# 7 "lib/radix-clear.c" 2


# 1 "include/linux/notifier.h" 1
# 14 "include/linux/notifier.h"
struct notifier_block
{
        int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
        struct notifier_block *next;
        int priority;
};




extern int notifier_chain_register(struct notifier_block **list, struct notifier_block *n);
extern int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n);
extern int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v);
# 10 "lib/radix-clear.c" 2
# 1 "include/linux/cpu.h" 1
# 22 "include/linux/cpu.h"
# 1 "include/linux/sysdev.h" 1
# 27 "include/linux/sysdev.h"
struct sys_device;

struct sysdev_class {
        struct list_head drivers;


        int (*shutdown)(struct sys_device *);
        int (*suspend)(struct sys_device *, u32 state);
        int (*resume)(struct sys_device *);
        struct kset kset;
};


extern int sysdev_class_register(struct sysdev_class *);
extern void sysdev_class_unregister(struct sysdev_class *);






struct sysdev_driver {
        struct list_head entry;
        int (*add)(struct sys_device *);
        int (*remove)(struct sys_device *);
        int (*shutdown)(struct sys_device *);
        int (*suspend)(struct sys_device *, u32 state);
        int (*resume)(struct sys_device *);
};


extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);







struct sys_device {
        u32 id;
        struct sysdev_class * cls;
        struct kobject kobj;
};

extern int sysdev_register(struct sys_device *);
extern void sysdev_unregister(struct sys_device *);


struct sysdev_attribute {
        struct attribute attr;
        ssize_t (*show)(struct sys_device *, char *);
        ssize_t (*store)(struct sys_device *, const char *, size_t);
};
# 91 "include/linux/sysdev.h"
extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
# 23 "include/linux/cpu.h" 2
# 1 "include/linux/node.h" 1
# 25 "include/linux/node.h"
struct node {
        struct sys_device sysdev;
};

extern int register_node(struct node *, int, struct node *);
# 24 "include/linux/cpu.h" 2




struct cpu {
        int node_id;
        int no_control;
        struct sys_device sysdev;
};

extern int register_cpu(struct cpu *, int, struct node *);
struct notifier_block;



extern int register_cpu_notifier(struct notifier_block *nb);
extern void unregister_cpu_notifier(struct notifier_block *nb);

int cpu_up(unsigned int cpu);
# 55 "include/linux/cpu.h"
extern struct sysdev_class cpu_sysdev_class;
# 77 "include/linux/cpu.h"
static inline __attribute__((always_inline)) int cpu_is_offline(int cpu) { return 0; }
# 11 "lib/radix-clear.c" 2
# 30 "lib/radix-clear.c"
struct radix_tree_node {
        unsigned int count;
        void *slots[(1UL << 6)];
        unsigned long tags[2][(((1UL << 6) + 64 - 1) / 64)];
};

struct radix_tree_path {
        struct radix_tree_node *node, **slot;
        int offset;
};




extern unsigned long height_to_maxindex[((8 * sizeof(unsigned long))/6 + 2)];






static inline __attribute__((always_inline)) unsigned long radix_tree_maxindex(unsigned int height)
{
        return height_to_maxindex[height];
}


static inline __attribute__((always_inline)) void tag_clear(struct radix_tree_node *node, int tag, int offset)
{
        __clear_bit(offset, &node->tags[tag][0]);
}
# 76 "lib/radix-clear.c"
void *radix_tree_tag_clear(struct radix_tree_root *root,
                        unsigned long index, int tag)
{
        struct radix_tree_path path[((8 * sizeof(unsigned long))/6 + 2)], *pathp = path;
        unsigned int height, shift;
        void *ret = ((void *)0);

        height = root->height;
        if (index > radix_tree_maxindex(height))
                goto out;

        shift = (height - 1) * 6;
        pathp->node = ((void *)0);
        pathp->slot = &root->rnode;

        while (height > 0) {
                int offset;

                if (*pathp->slot == ((void *)0))
                        goto out;

                offset = (index >> shift) & ((1UL << 6)-1);
                pathp[1].offset = offset;
                pathp[1].node = *pathp[0].slot;
                pathp[1].slot = (struct radix_tree_node **)
                                (pathp[1].node->slots + offset);
                pathp++;
                shift -= 6;
                height--;
        }

        ret = *pathp[0].slot;
        if (ret == ((void *)0))
                goto out;

        do {
                int idx;

                tag_clear(pathp[0].node, tag, pathp[0].offset);
                for (idx = 0; idx < (((1UL << 6) + 64 - 1) / 64); idx++) {
                        if (pathp[0].node->tags[tag][idx])
                                goto out;
                }
                pathp--;
        } while (pathp[0].node);
out:
        return ret;
}
 static const char __kstrtab_radix_tree_tag_clear[] __attribute__((section("__ksymtab_strings"))) = "" "radix_tree_tag_clear"; static const struct kernel_symbol __ksymtab_radix_tree_tag_clear __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&radix_tree_tag_clear, __kstrtab_radix_tree_tag_clear };