struct oldold_utsname {
 char sysname[9];
 char nodename[9];
 char release[9];
 char version[9];
 char machine[9];
};
struct old_utsname {
 char sysname[65];
 char nodename[65];
 char release[65];
 char version[65];
 char machine[65];
};
struct new_utsname {
 char sysname[65];
 char nodename[65];
 char release[65];
 char version[65];
 char machine[65];
 char domainname[65];
};
extern struct new_utsname system_utsname;
extern struct rw_semaphore uts_sem;
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;
typedef unsigned long __kernel_ino_t;
typedef unsigned int __kernel_mode_t;
typedef unsigned short __kernel_nlink_t;
typedef long __kernel_off_t;
typedef int __kernel_pid_t;
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
typedef unsigned int __kernel_size_t;
typedef int __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 short __kernel_ipc_pid_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
typedef unsigned int __kernel_old_uid_t;
typedef unsigned int __kernel_old_gid_t;
typedef unsigned int __kernel_old_dev_t;
typedef long long __kernel_loff_t;
typedef struct {
 int val[2];
} __kernel_fsid_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, __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 int *tmp = (unsigned int *)p->fds_bits;
 int i;
 if (__builtin_constant_p((1024/(8 * sizeof(unsigned long))))) {
  switch ((1024/(8 * sizeof(unsigned long)))) {
   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;
  }
 }
 i = (1024/(8 * sizeof(unsigned long)));
 while (i) {
  i--;
  *tmp = 0;
  tmp++;
 }
}
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 struct {
 __u32 u[4];
} __vector128;
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;
typedef __vector128 vector128;
typedef u32 dma_addr_t;
typedef u64 dma64_addr_t;
typedef unsigned int kmem_bufctl_t;
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_loff_t loff_t;
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;
typedef unsigned long sector_t;
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
struct ustat {
 __kernel_daddr_t f_tfree;
 __kernel_ino_t f_tinode;
 char f_fname[6];
 char f_fpack[6];
};
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;
struct restart_block {
 long (*fn)(struct restart_block *);
 unsigned long arg0, arg1, arg2, arg3;
};
extern long do_no_restart_syscall(struct restart_block *parm);
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;
}
static __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)) unsigned ld_le16(const volatile unsigned short *addr)
{
 unsigned val;
 __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (addr), "m" (*addr));
 return val;
}
extern __inline__ __attribute__((always_inline)) void st_le16(volatile unsigned short *addr, const unsigned val)
{
 __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*addr) : "r" (val), "r" (addr));
}
extern __inline__ __attribute__((always_inline)) unsigned ld_le32(const volatile unsigned *addr)
{
 unsigned val;
 __asm__ __volatile__ ("lwbrx %0,0,%1" : "=r" (val) : "r" (addr), "m" (*addr));
 return val;
}
extern __inline__ __attribute__((always_inline)) void st_le32(volatile unsigned *addr, const unsigned val)
{
 __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*addr) : "r" (val), "r" (addr));
}
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 ___arch__swab16(__u16 value)
{
 __u16 result;
 __asm__("rlwimi %0,%2,8,16,23" : "=&r" (result) : "0" (value >> 8), "r" (value));
 return result;
}
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swab32(__u32 value)
{
 __u32 result;
 __asm__("rlwimi %0,%2,24,16,23" : "=&r" (result) : "0" (value>>24), "r" (value));
 __asm__("rlwimi %0,%2,8,8,15" : "=&r" (result) : "0" (result), "r" (value));
 __asm__("rlwimi %0,%2,24,0,7" : "=&r" (result) : "0" (result), "r" (value));
 return result;
}
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 x)
{
 return ___arch__swab16(x);
}
static __inline__ __attribute__((always_inline)) __u16 __swab16p(const __u16 *x)
{
 return ld_le16(x);
}
static __inline__ __attribute__((always_inline)) void __swab16s(__u16 *addr)
{
 st_le16(addr,*addr);
}
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 ld_le32(x);
}
static __inline__ __attribute__((always_inline)) void __swab32s(__u32 *addr)
{
 st_le32(addr,*addr);
}
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 __fswab64(__u64 x)
{
 __u32 h = x >> 32;
        __u32 l = x & ((1ULL<<32)-1);
        return (((__u64)(__builtin_constant_p((__u32)(l)) ? ({ __u32 __x = ((l)); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((l)))) << 32) | ((__u64)((__builtin_constant_p((__u32)(h)) ? ({ __u32 __x = ((h)); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((h)))));
}
static __inline__ __attribute__((always_inline)) __u64 __swab64p(const __u64 *x)
{
 return ({ __u64 __tmp = (*(x)) ; ({ __u64 __x = (__tmp); ((__u64)( (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); }); });
}
static __inline__ __attribute__((always_inline)) void __swab64s(__u64 *addr)
{
 do { *(addr) = ({ __u64 __tmp = (*((addr))) ; ({ __u64 __x = (__tmp); ((__u64)( (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); }); }); } while (0);
}
static inline __attribute__((always_inline)) __le64 __cpu_to_le64p(const __u64 *p)
{
 return ( __le64)__swab64p(p);
}
static inline __attribute__((always_inline)) __u64 __le64_to_cpup(const __le64 *p)
{
 return __swab64p((__u64 *)p);
}
static inline __attribute__((always_inline)) __le32 __cpu_to_le32p(const __u32 *p)
{
 return ( __le32)__swab32p(p);
}
static inline __attribute__((always_inline)) __u32 __le32_to_cpup(const __le32 *p)
{
 return __swab32p((__u32 *)p);
}
static inline __attribute__((always_inline)) __le16 __cpu_to_le16p(const __u16 *p)
{
 return ( __le16)__swab16p(p);
}
static inline __attribute__((always_inline)) __u16 __le16_to_cpup(const __le16 *p)
{
 return __swab16p((__u16 *)p);
}
static inline __attribute__((always_inline)) __be64 __cpu_to_be64p(const __u64 *p)
{
 return ( __be64)*p;
}
static inline __attribute__((always_inline)) __u64 __be64_to_cpup(const __be64 *p)
{
 return ( __u64)*p;
}
static inline __attribute__((always_inline)) __be32 __cpu_to_be32p(const __u32 *p)
{
 return ( __be32)*p;
}
static inline __attribute__((always_inline)) __u32 __be32_to_cpup(const __be32 *p)
{
 return ( __u32)*p;
}
static inline __attribute__((always_inline)) __be16 __cpu_to_be16p(const __u16 *p)
{
 return ( __be16)*p;
}
static inline __attribute__((always_inline)) __u16 __be16_to_cpup(const __be16 *p)
{
 return ( __u16)*p;
}
extern __u32 ntohl(__be32);
extern __be32 htonl(__u32);
extern __u16 ntohs(__be16);
extern __be16 htons(__u16);
typedef struct { volatile int counter; } atomic_t;
extern void atomic_clear_mask(unsigned long mask, unsigned long *addr);
static __inline__ __attribute__((always_inline)) void atomic_add(int a, atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%3		# atomic_add\n	add	%0,%2,%0\n"
"	stwcx.	%0,0,%3 \n	bne-	1b"
 : "=&r" (t), "=m" (v->counter)
 : "r" (a), "r" (&v->counter), "m" (v->counter)
 : "cc");
}
static __inline__ __attribute__((always_inline)) int atomic_add_return(int a, atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%2		# atomic_add_return\n	add	%0,%1,%0\n"
"	stwcx.	%0,0,%2 \n	bne-	1b"
 : "=&r" (t)
 : "r" (a), "r" (&v->counter)
 : "cc", "memory");
 return t;
}
static __inline__ __attribute__((always_inline)) void atomic_sub(int a, atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%3		# atomic_sub\n	subf	%0,%2,%0\n"
"	stwcx.	%0,0,%3 \n	bne-	1b"
 : "=&r" (t), "=m" (v->counter)
 : "r" (a), "r" (&v->counter), "m" (v->counter)
 : "cc");
}
static __inline__ __attribute__((always_inline)) int atomic_sub_return(int a, atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%2		# atomic_sub_return\n	subf	%0,%1,%0\n"
"	stwcx.	%0,0,%2 \n	bne-	1b"
 : "=&r" (t)
 : "r" (a), "r" (&v->counter)
 : "cc", "memory");
 return t;
}
static __inline__ __attribute__((always_inline)) void atomic_inc(atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%2		# atomic_inc\n	addic	%0,%0,1\n"
"	stwcx.	%0,0,%2 \n	bne-	1b"
 : "=&r" (t), "=m" (v->counter)
 : "r" (&v->counter), "m" (v->counter)
 : "cc");
}
static __inline__ __attribute__((always_inline)) int atomic_inc_return(atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%1		# atomic_inc_return\n	addic	%0,%0,1\n"
"	stwcx.	%0,0,%1 \n	bne-	1b"
 : "=&r" (t)
 : "r" (&v->counter)
 : "cc", "memory");
 return t;
}
static __inline__ __attribute__((always_inline)) void atomic_dec(atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%2		# atomic_dec\n	addic	%0,%0,-1\n"
 "	stwcx.	%0,0,%2\n	bne-	1b"
 : "=&r" (t), "=m" (v->counter)
 : "r" (&v->counter), "m" (v->counter)
 : "cc");
}
static __inline__ __attribute__((always_inline)) int atomic_dec_return(atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%1		# atomic_dec_return\n	addic	%0,%0,-1\n"
"	stwcx.	%0,0,%1\n	bne-	1b"
 : "=&r" (t)
 : "r" (&v->counter)
 : "cc", "memory");
 return t;
}
static __inline__ __attribute__((always_inline)) int atomic_dec_if_positive(atomic_t *v)
{
 int t;
 __asm__ __volatile__(
"1:	lwarx	%0,0,%1		# atomic_dec_if_positive\n	addic.	%0,%0,-1\n	blt-	2f\n"
"	stwcx.	%0,0,%1\n	bne-	1b"
 "\n2:" : "=&r" (t)
 : "r" (&v->counter)
 : "cc", "memory");
 return t;
}
static __inline__ __attribute__((always_inline)) void set_bit(int nr, volatile unsigned long * addr)
{
 unsigned long old;
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 __asm__ __volatile__("\n1:	lwarx	%0,0,%3 \n	or	%0,%0,%2 \n"
"	stwcx.	%0,0,%3 \n	bne-	1b"
 : "=&r" (old), "=m" (*p)
 : "r" (mask), "r" (p), "m" (*p)
 : "cc" );
}
static __inline__ __attribute__((always_inline)) void __set_bit(int nr, volatile unsigned long *addr)
{
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 *p |= mask;
}
static __inline__ __attribute__((always_inline)) void clear_bit(int nr, volatile unsigned long *addr)
{
 unsigned long old;
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 __asm__ __volatile__("\n1:	lwarx	%0,0,%3 \n	andc	%0,%0,%2 \n"
"	stwcx.	%0,0,%3 \n	bne-	1b"
 : "=&r" (old), "=m" (*p)
 : "r" (mask), "r" (p), "m" (*p)
 : "cc");
}
static __inline__ __attribute__((always_inline)) void __clear_bit(int nr, volatile unsigned long *addr)
{
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 *p &= ~mask;
}
static __inline__ __attribute__((always_inline)) void change_bit(int nr, volatile unsigned long *addr)
{
 unsigned long old;
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 __asm__ __volatile__("\n1:	lwarx	%0,0,%3 \n	xor	%0,%0,%2 \n"
"	stwcx.	%0,0,%3 \n	bne-	1b"
 : "=&r" (old), "=m" (*p)
 : "r" (mask), "r" (p), "m" (*p)
 : "cc");
}
static __inline__ __attribute__((always_inline)) void __change_bit(int nr, volatile unsigned long *addr)
{
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 *p ^= mask;
}
static __inline__ __attribute__((always_inline)) int test_and_set_bit(int nr, volatile unsigned long *addr)
{
 unsigned int old, t;
 unsigned int mask = 1 << (nr & 0x1f);
 volatile unsigned int *p = ((volatile unsigned int *)addr) + (nr >> 5);
 __asm__ __volatile__( "\n1:	lwarx	%0,0,%4 \n	or	%1,%0,%3 \n"
"	stwcx.	%1,0,%4 \n	bne	1b"
 : "=&r" (old), "=&r" (t), "=m" (*p)
 : "r" (mask), "r" (p), "m" (*p)
 : "cc", "memory");
 return (old & mask) != 0;
}
static __inline__ __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile unsigned long *addr)
{
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 unsigned long old = *p;
 *p = old | mask;
 return (old & mask) != 0;
}
static __inline__ __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile unsigned long *addr)
{
 unsigned int old, t;
 unsigned int mask = 1 << (nr & 0x1f);
 volatile unsigned int *p = ((volatile unsigned int *)addr) + (nr >> 5);
 __asm__ __volatile__( "\n1:	lwarx	%0,0,%4 \n	andc	%1,%0,%3 \n"
"	stwcx.	%1,0,%4 \n	bne	1b"
 : "=&r" (old), "=&r" (t), "=m" (*p)
 : "r" (mask), "r" (p), "m" (*p)
 : "cc", "memory");
 return (old & mask) != 0;
}
static __inline__ __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile unsigned long *addr)
{
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 unsigned long old = *p;
 *p = old & ~mask;
 return (old & mask) != 0;
}
static __inline__ __attribute__((always_inline)) int test_and_change_bit(int nr, volatile unsigned long *addr)
{
 unsigned int old, t;
 unsigned int mask = 1 << (nr & 0x1f);
 volatile unsigned int *p = ((volatile unsigned int *)addr) + (nr >> 5);
 __asm__ __volatile__( "\n1:	lwarx	%0,0,%4 \n	xor	%1,%0,%3 \n"
"	stwcx.	%1,0,%4 \n	bne	1b"
 : "=&r" (old), "=&r" (t), "=m" (*p)
 : "r" (mask), "r" (p), "m" (*p)
 : "cc", "memory");
 return (old & mask) != 0;
}
static __inline__ __attribute__((always_inline)) int __test_and_change_bit(int nr, volatile unsigned long *addr)
{
 unsigned long mask = 1 << (nr & 0x1f);
 unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
 unsigned long old = *p;
 *p = old ^ mask;
 return (old & mask) != 0;
}
static __inline__ __attribute__((always_inline)) int test_bit(int nr, __const__ volatile unsigned long *addr)
{
 return ((addr[nr >> 5] >> (nr & 0x1f)) & 1) != 0;
}
static __inline__ __attribute__((always_inline)) int __ilog2(unsigned long x)
{
 int lz;
 asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
 return 31 - lz;
}
static __inline__ __attribute__((always_inline)) int ffz(unsigned long x)
{
 if ((x = ~x) == 0)
  return 32;
 return __ilog2(x & -x);
}
static inline __attribute__((always_inline)) int __ffs(unsigned long x)
{
 return __ilog2(x & -x);
}
static __inline__ __attribute__((always_inline)) int ffs(int x)
{
 return __ilog2(x & -x) + 1;
}
static __inline__ __attribute__((always_inline)) int fls(unsigned int x)
{
 int lz;
 asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
 return 32 - lz;
}
static inline __attribute__((always_inline)) int sched_find_first_bit(const unsigned long *b)
{
 if (__builtin_expect(!!(b[0]), 0))
  return __ffs(b[0]);
 if (__builtin_expect(!!(b[1]), 0))
  return __ffs(b[1]) + 32;
 if (__builtin_expect(!!(b[2]), 0))
  return __ffs(b[2]) + 64;
 if (b[3])
  return __ffs(b[3]) + 96;
 return __ffs(b[4]) + 128;
}
static __inline__ __attribute__((always_inline)) unsigned long find_next_bit(const unsigned long *addr,
 unsigned long size, unsigned long offset)
{
 unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
 unsigned int result = offset & ~31UL;
 unsigned int tmp;
 if (offset >= size)
  return size;
 size -= result;
 offset &= 31UL;
 if (offset) {
  tmp = *p++;
  tmp &= ~0UL << offset;
  if (size < 32)
   goto found_first;
  if (tmp)
   goto found_middle;
  size -= 32;
  result += 32;
 }
 while (size >= 32) {
  if ((tmp = *p++) != 0)
   goto found_middle;
  result += 32;
  size -= 32;
 }
 if (!size)
  return result;
 tmp = *p;
found_first:
 tmp &= ~0UL >> (32 - size);
 if (tmp == 0UL)
  return result + size;
found_middle:
 return result + __ffs(tmp);
}
static __inline__ __attribute__((always_inline)) unsigned long find_next_zero_bit(const unsigned long *addr,
 unsigned long size, unsigned long offset)
{
 unsigned int * p = ((unsigned int *) addr) + (offset >> 5);
 unsigned int result = offset & ~31UL;
 unsigned int tmp;
 if (offset >= size)
  return size;
 size -= result;
 offset &= 31UL;
 if (offset) {
  tmp = *p++;
  tmp |= ~0UL >> (32-offset);
  if (size < 32)
   goto found_first;
  if (tmp != ~0U)
   goto found_middle;
  size -= 32;
  result += 32;
 }
 while (size >= 32) {
  if ((tmp = *p++) != ~0U)
   goto found_middle;
  result += 32;
  size -= 32;
 }
 if (!size)
  return result;
 tmp = *p;
found_first:
 tmp |= ~0UL << size;
 if (tmp == ~0UL)
  return result + size;
found_middle:
 return result + ffz(tmp);
}
static __inline__ __attribute__((always_inline)) int ext2_test_bit(int nr, __const__ void * addr)
{
 __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
 return (ADDR[nr >> 3] >> (nr & 7)) & 1;
}
static __inline__ __attribute__((always_inline)) unsigned long ext2_find_next_zero_bit(const void *addr,
 unsigned long size, unsigned long offset)
{
 unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
 unsigned int result = offset & ~31UL;
 unsigned int tmp;
 if (offset >= size)
  return size;
 size -= result;
 offset &= 31UL;
 if (offset) {
  tmp = __cpu_to_le32p(p++);
  tmp |= ~0UL >> (32-offset);
  if (size < 32)
   goto found_first;
  if (tmp != ~0U)
   goto found_middle;
  size -= 32;
  result += 32;
 }
 while (size >= 32) {
  if ((tmp = __cpu_to_le32p(p++)) != ~0U)
   goto found_middle;
  result += 32;
  size -= 32;
 }
 if (!size)
  return result;
 tmp = __cpu_to_le32p(p);
found_first:
 tmp |= ~0U << size;
 if (tmp == ~0UL)
  return result + size;
found_middle:
 return result + ffz(tmp);
}
static __inline__ __attribute__((always_inline)) int get_bitmask_order(unsigned int count)
{
 int order;
 order = 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)
{
 return generic_hweight32((unsigned int)(w >> 32)) +
    generic_hweight32((unsigned int)w);
}
static inline __attribute__((always_inline)) unsigned long hweight_long(unsigned long w)
{
 return sizeof(w) == 4 ? generic_hweight32(w) : generic_hweight64(w);
}
struct thread_info {
 struct task_struct *task;
 struct exec_domain *exec_domain;
 unsigned long flags;
 unsigned long local_flags;
 int cpu;
 int preempt_count;
 struct restart_block restart_block;
};
static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
{
 struct thread_info *ti;
 __asm__("rlwinm %0,1,0,0,18" : "=r"(ti));
 return ti;
}
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 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 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);
}
typedef __builtin_va_list __gnuc_va_list;
typedef __gnuc_va_list va_list;
struct bug_entry {
 unsigned long bug_addr;
 int line;
 const char *file;
 const char *function;
};
extern const char linux_banner[];
extern int console_printk[];
struct completion;
extern struct notifier_block *panic_notifier_list;
extern long (*panic_blink)(long time);
 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 << 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_timeout;
extern int panic_on_oops;
extern int tainted;
extern const char *print_tainted(void);
extern void add_taint(unsigned);
extern enum system_states {
 SYSTEM_BOOTING,
 SYSTEM_RUNNING,
 SYSTEM_HALT,
 SYSTEM_POWER_OFF,
 SYSTEM_RESTART,
} system_state;
extern void dump_stack(void);
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);
struct pt_regs {
 unsigned long gpr[32];
 unsigned long nip;
 unsigned long msr;
 unsigned long orig_gpr3;
 unsigned long ctr;
 unsigned long link;
 unsigned long xer;
 unsigned long ccr;
 unsigned long mq;
 unsigned long trap;
 unsigned long dar;
 unsigned long dsisr;
 unsigned long result;
};
extern int _machine;
extern int _prep_type;
extern int _chrp_type;
extern unsigned char ucSystemType;
extern unsigned char ucBoardRev;
extern unsigned char ucBoardRevMaj, ucBoardRevMin;
struct task_struct;
void start_thread(struct pt_regs *regs, unsigned long nip, unsigned long sp);
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 struct task_struct *last_task_used_math;
extern struct task_struct *last_task_used_altivec;
extern struct task_struct *last_task_used_spe;
typedef struct {
 unsigned long seg;
} mm_segment_t;
struct thread_struct {
 unsigned long ksp;
 struct pt_regs *regs;
 mm_segment_t fs;
 void *pgdir;
 int fpexc_mode;
 signed long last_syscall;
 double fpr[32];
 unsigned long fpscr_pad;
 unsigned long fpscr;
};
unsigned long get_wchan(struct task_struct *p);
extern int get_fpexc_mode(struct task_struct *tsk, unsigned long adr);
extern int set_fpexc_mode(struct task_struct *tsk, unsigned int val);
static inline __attribute__((always_inline)) unsigned int __unpack_fe01(unsigned int msr_bits)
{
 return ((msr_bits & (1<<11)) >> 10) | ((msr_bits & (1<<8)) >> 8);
}
static inline __attribute__((always_inline)) unsigned int __pack_fe01(unsigned int fpmode)
{
 return ((fpmode << 10) & (1<<11)) | ((fpmode << 8) & (1<<8));
}
int ll_printk(const char *, ...);
void ll_puts(const char *);
void _nmask_and_or_msr(unsigned long nmask, unsigned long or_val);
extern inline __attribute__((always_inline)) void prefetch(const void *x)
{
  __asm__ __volatile__ ("dcbt 0,%0" : : "r" (x));
}
extern inline __attribute__((always_inline)) void prefetchw(const void *x)
{
  __asm__ __volatile__ ("dcbtst 0,%0" : : "r" (x));
}
extern int emulate_altivec(struct pt_regs *regs);
extern void timer_interrupt(struct pt_regs *);
static inline __attribute__((always_inline)) void local_irq_disable(void)
{
 unsigned long msr;
 msr = ({unsigned int rval; asm volatile("mfmsr %0" : "=r" (rval)); rval;});
 asm volatile("mtmsr %0" : : "r" (msr & ~(1<<15)));
 __asm__ __volatile__("": : :"memory");
}
static inline __attribute__((always_inline)) void local_irq_enable(void)
{
 unsigned long msr;
 __asm__ __volatile__("": : :"memory");
 msr = ({unsigned int rval; asm volatile("mfmsr %0" : "=r" (rval)); rval;});
 asm volatile("mtmsr %0" : : "r" (msr | (1<<15)));
}
static inline __attribute__((always_inline)) void local_irq_save_ptr(unsigned long *flags)
{
 unsigned long msr;
 msr = ({unsigned int rval; asm volatile("mfmsr %0" : "=r" (rval)); rval;});
 *flags = msr;
 asm volatile("mtmsr %0" : : "r" (msr & ~(1<<15)));
 __asm__ __volatile__("": : :"memory");
}
extern void do_lost_interrupts(unsigned long);
struct hw_interrupt_type;
static inline __attribute__((always_inline)) void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
struct task_struct;
struct pt_regs;
extern void print_backtrace(unsigned long *);
extern void show_regs(struct pt_regs * regs);
extern void flush_instruction_cache(void);
extern void hard_reset_now(void);
extern void poweroff_now(void);
extern long _get_L2CR(void);
extern long _get_L3CR(void);
extern void _set_L2CR(unsigned long);
extern void _set_L3CR(unsigned long);
extern void via_cuda_init(void);
extern void pmac_nvram_init(void);
extern void read_rtc_time(void);
extern void pmac_find_display(void);
extern void giveup_fpu(struct task_struct *);
extern void enable_kernel_fp(void);
extern void enable_kernel_altivec(void);
extern void giveup_altivec(struct task_struct *);
extern void load_up_altivec(struct task_struct *);
extern void giveup_spe(struct task_struct *);
extern void load_up_spe(struct task_struct *);
extern int fix_alignment(struct pt_regs *);
extern void cvt_fd(float *from, double *to, unsigned long *fpscr);
extern void cvt_df(double *from, float *to, unsigned long *fpscr);
extern int call_rtas(const char *, int, int, unsigned long *, ...);
extern void cacheable_memzero(void *p, unsigned int nb);
extern int do_page_fault(struct pt_regs *, unsigned long, unsigned long);
extern void bad_page_fault(struct pt_regs *, unsigned long, int);
extern void die(const char *, struct pt_regs *, long);
struct device_node;
extern void note_scsi_host(struct device_node *, void *);
extern struct task_struct *__switch_to(struct task_struct *,
 struct task_struct *);
struct thread_struct;
extern struct task_struct *_switch(struct thread_struct *prev,
       struct thread_struct *next);
extern unsigned int rtas_data;
static __inline__ __attribute__((always_inline)) unsigned long
xchg_u32(volatile void *p, unsigned long val)
{
 unsigned long prev;
 __asm__ __volatile__ ("\n1:	lwarx	%0,0,%2 \n"
"	stwcx.	%3,0,%2 \n	bne-	1b"
 : "=&r" (prev), "=m" (*(volatile unsigned long *)p)
 : "r" (p), "r" (val), "m" (*(volatile unsigned long *)p)
 : "cc", "memory");
 return prev;
}
extern void __xchg_called_with_bad_pointer(void);
static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
{
 switch (size) {
 case 4:
  return (unsigned long) xchg_u32(ptr, x);
 }
 __xchg_called_with_bad_pointer();
 return x;
}
extern inline __attribute__((always_inline)) void * xchg_ptr(void * m, void * val)
{
 return (void *) xchg_u32(m, (unsigned long) val);
}
static __inline__ __attribute__((always_inline)) unsigned long
__cmpxchg_u32(volatile int *p, int old, int new)
{
 int prev;
 __asm__ __volatile__ ("\n1:	lwarx	%0,0,%2 \n	cmpw	0,%0,%3 \n	bne	2f \n"
"	stwcx.	%4,0,%2 \n	bne-	1b\n"
"2:"
 : "=&r" (prev), "=m" (*p)
 : "r" (p), "r" (old), "r" (new), "m" (*p)
 : "cc", "memory");
 return prev;
}
extern void __cmpxchg_called_with_bad_pointer(void);
static __inline__ __attribute__((always_inline)) unsigned long
__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
{
 switch (size) {
 case 4:
  return __cmpxchg_u32(ptr, old, new);
 }
 __cmpxchg_called_with_bad_pointer();
 return old;
}
  typedef struct { } spinlock_t;
  typedef struct { } rwlock_t;
static inline __attribute__((always_inline)) void bit_spin_lock(int bitnum, unsigned long *addr)
{
 do { } while (0);
 (void)0;
}
static inline __attribute__((always_inline)) int bit_spin_trylock(int bitnum, unsigned long *addr)
{
 do { } while (0);
 (void)0;
 return 1;
}
static inline __attribute__((always_inline)) void bit_spin_unlock(int bitnum, unsigned long *addr)
{
 do { } while (0);
 (void)0;
}
static inline __attribute__((always_inline)) int bit_spin_is_locked(int bitnum, unsigned long *addr)
{
 return 1;
}
extern spinlock_t task_capability_lock;
typedef __u32 kernel_cap_t;
extern kernel_cap_t cap_bset;
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;
}
typedef struct {
 unsigned sequence;
 spinlock_t lock;
} seqlock_t;
static inline __attribute__((always_inline)) void write_seqlock(seqlock_t *sl)
{
 do { do { } while (0); do { (void)(&sl->lock); } while(0); (void)0; } while(0);
 ++sl->sequence;
 __asm__ __volatile__("": : :"memory");
}
static inline __attribute__((always_inline)) void write_sequnlock(seqlock_t *sl)
{
 __asm__ __volatile__("": : :"memory");
 sl->sequence++;
 do { do { (void)(&sl->lock); } while(0); do { } while (0); (void)0; } while (0);
}
static inline __attribute__((always_inline)) int write_tryseqlock(seqlock_t *sl)
{
 int ret = (({do { } while (0); (((void)(&sl->lock), 1)) ? 1 : ({do { } while (0); 0;});}));
 if (ret) {
  ++sl->sequence;
  __asm__ __volatile__("": : :"memory");
 }
 return ret;
}
static inline __attribute__((always_inline)) unsigned read_seqbegin(const seqlock_t *sl)
{
 unsigned ret = sl->sequence;
 __asm__ __volatile__("": : :"memory");
 return ret;
}
static inline __attribute__((always_inline)) int read_seqretry(const seqlock_t *sl, unsigned iv)
{
 __asm__ __volatile__("": : :"memory");
 return (iv & 1) | (sl->sequence ^ iv);
}
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__("": : :"memory");
 return ret;
}
static inline __attribute__((always_inline)) int read_seqcount_retry(const seqcount_t *s, unsigned iv)
{
 __asm__ __volatile__("": : :"memory");
 return (iv & 1) | (s->sequence ^ iv);
}
static inline __attribute__((always_inline)) void write_seqcount_begin(seqcount_t *s)
{
 s->sequence++;
 __asm__ __volatile__("": : :"memory");
}
static inline __attribute__((always_inline)) void write_seqcount_end(seqcount_t *s)
{
 __asm__ __volatile__("": : :"memory");
 s->sequence++;
}
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;
};
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);
}
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);
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);
extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
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;
}
struct itimerspec {
        struct timespec it_interval;
        struct timespec it_value;
};
struct itimerval {
 struct timeval it_interval;
 struct timeval it_value;
};
struct cpu_spec;
typedef void (*cpu_setup_t)(unsigned long offset, int cpu_nr, struct cpu_spec* spec);
struct cpu_spec {
 unsigned int pvr_mask;
 unsigned int pvr_value;
 char *cpu_name;
 unsigned int cpu_features;
 unsigned int cpu_user_features;
 unsigned int icache_bsize;
 unsigned int dcache_bsize;
 unsigned int num_pmcs;
 cpu_setup_t cpu_setup;
};
extern struct cpu_spec cpu_specs[];
extern struct cpu_spec *cur_cpu_spec[];
typedef unsigned long cycles_t;
extern cycles_t cacheflush_time;
static inline __attribute__((always_inline)) cycles_t get_cycles(void)
{
 cycles_t ret = 0;
 __asm__ __volatile__(
  "98:	mftb %0\n"
  "99:\n"
  ".section __ftr_fixup,\"a\"\n"
  "	.long %1\n"
  "	.long 0\n"
  "	.long 98b\n"
  "	.long 99b\n"
  ".previous"
  : "=r" (ret) : "i" (0x00000100));
 return ret;
}
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;
};
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;
static inline __attribute__((always_inline)) void
time_interpolator_reset(void)
{
}
extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
extern u64 __attribute__((section(".data"))) jiffies_64;
extern unsigned long volatile __attribute__((section(".data"))) jiffies;
u64 get_jiffies_64(void);
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);
}
static inline __attribute__((always_inline)) unsigned long usecs_to_jiffies(const unsigned int u)
{
 if (u > jiffies_to_usecs(((~0UL >> 1)-1)))
  return ((~0UL >> 1)-1);
 return (u + (1000000 / 1000) - 1) / (1000000 / 1000);
}
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 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))))) - 1;
 if (sec >= (long)((u64)((u64)((~0UL >> 1)-1) * (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))))) / (1000000000L))){
  sec = (long)((u64)((u64)((~0UL >> 1)-1) * (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))))) / (1000000000L));
  nsec = 0;
 }
 return (((u64)sec * ((unsigned long)((((u64)(1000000000L) << (32 - 10)) + (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))))))) +
  (((u64)nsec * ((unsigned long)((((u64)1 << ((32 - 10) + 29)) + (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 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 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))));
 value->tv_sec = ({ u64 result = nsec; *&value->tv_nsec = ({ uint32_t __base = ((1000000000L)); uint32_t __rem; (void)(((typeof((result)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((result) >> 32) == 0), 1)) { __rem = (uint32_t)(result) % __base; (result) = (uint32_t)(result) / __base; } else __rem = __div64_32(&(result), __base); __rem; }); result; });
}
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 >= (long)((u64)((u64)((~0UL >> 1)-1) * (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))))) / (1000000000L))){
  sec = (long)((u64)((u64)((~0UL >> 1)-1) * (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))))) / (1000000000L));
  usec = 0;
 }
 return (((u64)sec * ((unsigned long)((((u64)(1000000000L) << (32 - 10)) + (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))))))) +
  (((u64)usec * ((unsigned long)((((u64)(1000L) << ((32 - 10) + 19)) + (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))))) -1) / (u64)(( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 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 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))));
 value->tv_sec = ({ u64 result = nsec; *&value->tv_usec = ({ uint32_t __base = ((1000000000L)); uint32_t __rem; (void)(((typeof((result)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((result) >> 32) == 0), 1)) { __rem = (uint32_t)(result) % __base; (result) = (uint32_t)(result) / __base; } else __rem = __div64_32(&(result), __base); __rem; }); result; });
 value->tv_usec /= (1000L);
}
static inline __attribute__((always_inline)) clock_t jiffies_to_clock_t(long x)
{
 u64 tmp = (u64)x * (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))));
 ({ uint32_t __base = (((1000000000L) / 100)); uint32_t __rem; (void)(((typeof((tmp)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((tmp) >> 32) == 0), 1)) { __rem = (uint32_t)(tmp) % __base; (tmp) = (uint32_t)(tmp) / __base; } else __rem = __div64_32(&(tmp), __base); __rem; });
 return (long)tmp;
}
static inline __attribute__((always_inline)) unsigned long clock_t_to_jiffies(unsigned long x)
{
 if (x >= ~0UL / (1000 / 100))
  return ~0UL;
 return x * (1000 / 100);
}
static inline __attribute__((always_inline)) u64 jiffies_64_to_clock_t(u64 x)
{
 x *= (( ((1000000UL * 1000 / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (((1000000UL * 1000 % (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))) << 8) + (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000))) / 2) / (( ((1193180 / ((1193180 + 1000/2) / 1000)) << 8) + (((1193180 % ((1193180 + 1000/2) / 1000)) << 8) + ((1193180 + 1000/2) / 1000) / 2) / ((1193180 + 1000/2) / 1000)))));
 ({ uint32_t __base = (((1000000000L) / 100)); uint32_t __rem; (void)(((typeof((x)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((x) >> 32) == 0), 1)) { __rem = (uint32_t)(x) % __base; (x) = (uint32_t)(x) / __base; } else __rem = __div64_32(&(x), __base); __rem; });
 return x;
}
static inline __attribute__((always_inline)) u64 nsec_to_clock_t(u64 x)
{
 ({ uint32_t __base = (((1000000000L) / 100)); uint32_t __rem; (void)(((typeof((x)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((x) >> 32) == 0), 1)) { __rem = (uint32_t)(x) % __base; (x) = (uint32_t)(x) / __base; } else __rem = __div64_32(&(x), __base); __rem; });
 return x;
}
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;
}
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 *);
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, int);
extern char * strcpy(char *,const char *);
extern char * strncpy(char *,const char *, __kernel_size_t);
extern __kernel_size_t strlen(const char *);
extern int strcmp(const char *,const char *);
extern char * strcat(char *, const char *);
extern void * memset(void *,int,__kernel_size_t);
extern void * memcpy(void *,const void *,__kernel_size_t);
extern void * memmove(void *,const void *,__kernel_size_t);
extern int memcmp(const void *,const void *,__kernel_size_t);
extern void * memchr(const void *,int,__kernel_size_t);
size_t strlcpy(char *, const char *, size_t);
extern char * strncat(char *, const char *, __kernel_size_t);
extern size_t strlcat(char *, const char *, __kernel_size_t);
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 strnlen(const char *,__kernel_size_t);
extern void * memscan(void *,int,__kernel_size_t);
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 <= 32)
  *dst = 0UL;
 else {
  int len = (((nbits)+32 -1)/32) * sizeof(unsigned long);
  memset(dst, 0, len);
 }
}
static inline __attribute__((always_inline)) void bitmap_fill(unsigned long *dst, int nbits)
{
 size_t nlongs = (((nbits)+32 -1)/32);
 if (nlongs > 1) {
  int len = (nlongs - 1) * sizeof(unsigned long);
  memset(dst, 0xff, len);
 }
 dst[nlongs - 1] = ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
}
static inline __attribute__((always_inline)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
   int nbits)
{
 if (nbits <= 32)
  *dst = *src;
 else {
  int len = (((nbits)+32 -1)/32) * sizeof(unsigned long);
  memcpy(dst, src, len);
 }
}
static inline __attribute__((always_inline)) void bitmap_and(unsigned long *dst, const unsigned long *src1,
   const unsigned long *src2, int nbits)
{
 if (nbits <= 32)
  *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 <= 32)
  *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 <= 32)
  *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 <= 32)
  *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 <= 32)
  *dst = ~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-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 <= 32)
  return ! ((*src1 ^ *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-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 <= 32)
  return ((*src1 & *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-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 <= 32)
  return ! ((*src1 & ~(*src2)) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-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 <= 32)
  return ! (*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
 else
  return __bitmap_empty(src, nbits);
}
static inline __attribute__((always_inline)) int bitmap_full(const unsigned long *src, int nbits)
{
 if (nbits <= 32)
  return ! (~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-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 <= 32)
  *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 <= 32)
  *dst = (*src << n) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
 else
  __bitmap_shift_left(dst, src, n, nbits);
}
typedef struct { unsigned long bits[(((1)+32 -1)/32)]; } 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 = (find_next_bit((srcp->bits), (nbits), 0)); __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 = (find_next_bit(srcp->bits, nbits, n+1)); __x < __y ? __x: __y; });
}
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);
}
extern cpumask_t cpu_possible_map;
extern cpumask_t cpu_online_map;
extern cpumask_t cpu_present_map;
extern void clean_dcache_range(unsigned long start, unsigned long stop);
extern void flush_dcache_range(unsigned long start, unsigned long stop);
extern void invalidate_dcache_range(unsigned long start, unsigned long stop);
extern void flush_dcache_all(void);
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*32))
  prefetch(cp);
}
struct list_head {
 struct list_head *next, *prev;
};
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;
}
static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
{
 __list_add(new, head, head->next);
}
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__("": : :"memory");
 next->prev = new;
 prev->next = new;
}
static inline __attribute__((always_inline)) void list_add_rcu(struct list_head *new, struct list_head *head)
{
 __list_add_rcu(new, head, head->next);
}
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);
}
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);
}
static inline __attribute__((always_inline)) void list_del_rcu(struct list_head *entry)
{
 __list_del(entry->prev, entry->next);
 entry->prev = ((void *) 0x00200200);
}
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__("": : :"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;
}
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);
}
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);
 }
}
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);
}
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;
}
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__("": : :"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;
}
register struct task_struct *current asm ("r2");
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_bit_key {
 void *flags;
 int bit_nr;
};
struct wait_bit_queue {
 struct wait_bit_key key;
 wait_queue_t wait;
};
struct __wait_queue_head {
 spinlock_t lock;
 struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
static inline __attribute__((always_inline)) void init_waitqueue_head(wait_queue_head_t *q)
{
 q->lock = (spinlock_t) { };
 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);
}
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);
void __wake_up_bit(wait_queue_head_t *, void *, int);
int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
void wake_up_bit(void *, int);
int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned);
int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned);
wait_queue_head_t *bit_waitqueue(void *, int);
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);
int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
static inline __attribute__((always_inline)) int wait_on_bit(void *word, int bit,
    int (*action)(void *), unsigned mode)
{
 if (!test_bit(bit, word))
  return 0;
 return out_of_line_wait_on_bit(word, bit, action, mode);
}
static inline __attribute__((always_inline)) int wait_on_bit_lock(void *word, int bit,
    int (*action)(void *), unsigned mode)
{
 if (!test_and_set_bit(bit, word))
  return 0;
 return out_of_line_wait_on_bit_lock(word, bit, action, mode);
}
struct rw_semaphore;
struct rw_semaphore {
 signed long count;
 spinlock_t wait_lock;
 struct list_head wait_list;
};
extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_down_write_failed(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem);
static inline __attribute__((always_inline)) void init_rwsem(struct rw_semaphore *sem)
{
 sem->count = 0x00000000;
 do { (void)(&sem->wait_lock); } while(0);
 do { (&sem->wait_list)->next = (&sem->wait_list); (&sem->wait_list)->prev = (&sem->wait_list); } while (0);
}
static inline __attribute__((always_inline)) void __down_read(struct rw_semaphore *sem)
{
 if (atomic_inc_return((atomic_t *)(&sem->count)) > 0)
  __asm__ __volatile__("": : :"memory");
 else
  rwsem_down_read_failed(sem);
}
static inline __attribute__((always_inline)) int __down_read_trylock(struct rw_semaphore *sem)
{
 int tmp;
 while ((tmp = sem->count) >= 0) {
  if (tmp == ({ __typeof__(*(&sem->count)) _o_ = (tmp); __typeof__(*(&sem->count)) _n_ = (tmp + 0x00000001); (__typeof__(*(&sem->count))) __cmpxchg((&sem->count), (unsigned long)_o_, (unsigned long)_n_, sizeof(*(&sem->count))); })) {
   __asm__ __volatile__("": : :"memory");
   return 1;
  }
 }
 return 0;
}
static inline __attribute__((always_inline)) void __down_write(struct rw_semaphore *sem)
{
 int tmp;
 tmp = atomic_add_return(((-0x00010000) + 0x00000001),
    (atomic_t *)(&sem->count));
 if (tmp == ((-0x00010000) + 0x00000001))
  __asm__ __volatile__("": : :"memory");
 else
  rwsem_down_write_failed(sem);
}
static inline __attribute__((always_inline)) int __down_write_trylock(struct rw_semaphore *sem)
{
 int tmp;
 tmp = ({ __typeof__(*(&sem->count)) _o_ = (0x00000000); __typeof__(*(&sem->count)) _n_ = (((-0x00010000) + 0x00000001)); (__typeof__(*(&sem->count))) __cmpxchg((&sem->count), (unsigned long)_o_, (unsigned long)_n_, sizeof(*(&sem->count))); });
 __asm__ __volatile__("": : :"memory");
 return tmp == 0x00000000;
}
static inline __attribute__((always_inline)) void __up_read(struct rw_semaphore *sem)
{
 int tmp;
 __asm__ __volatile__("": : :"memory");
 tmp = atomic_dec_return((atomic_t *)(&sem->count));
 if (tmp < -1 && (tmp & 0x0000ffff) == 0)
  rwsem_wake(sem);
}
static inline __attribute__((always_inline)) void __up_write(struct rw_semaphore *sem)
{
 __asm__ __volatile__("": : :"memory");
 if (atomic_sub_return(((-0x00010000) + 0x00000001),
         (atomic_t *)(&sem->count)) < 0)
  rwsem_wake(sem);
}
static inline __attribute__((always_inline)) void rwsem_atomic_add(int delta, struct rw_semaphore *sem)
{
 atomic_add(delta, (atomic_t *)(&sem->count));
}
static inline __attribute__((always_inline)) void __downgrade_write(struct rw_semaphore *sem)
{
 int tmp;
 __asm__ __volatile__("": : :"memory");
 tmp = atomic_add_return(-(-0x00010000), (atomic_t *)(&sem->count));
 if (tmp < 0)
  rwsem_downgrade_wake(sem);
}
static inline __attribute__((always_inline)) int rwsem_atomic_update(int delta, struct rw_semaphore *sem)
{
 __asm__ __volatile__("": : :"memory");
 return atomic_add_return(delta, (atomic_t *)(&sem->count));
}
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);
 ;
}
struct semaphore {
 atomic_t count;
 wait_queue_head_t wait;
};
static inline __attribute__((always_inline)) void sema_init (struct semaphore *sem, int val)
{
 (((&sem->count)->counter) = (val));
 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);
}
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
extern inline __attribute__((always_inline)) void down(struct semaphore * sem)
{
 do {} while(0);
 if (atomic_dec_return(&sem->count) < 0)
  __down(sem);
 __asm__ __volatile__("": : :"memory");
}
extern inline __attribute__((always_inline)) int down_interruptible(struct semaphore * sem)
{
 int ret = 0;
 do {} while(0);
 if (atomic_dec_return(&sem->count) < 0)
  ret = __down_interruptible(sem);
 __asm__ __volatile__("": : :"memory");
 return ret;
}
extern inline __attribute__((always_inline)) int down_trylock(struct semaphore * sem)
{
 int ret;
 ret = atomic_dec_if_positive(&sem->count) < 0;
 __asm__ __volatile__("": : :"memory");
 return ret;
}
extern inline __attribute__((always_inline)) void up(struct semaphore * sem)
{
 __asm__ __volatile__("": : :"memory");
 if (atomic_inc_return(&sem->count) <= 0)
  __up(sem);
}
typedef unsigned long pte_basic_t;
typedef pte_basic_t pte_t;
typedef unsigned long pmd_t;
typedef unsigned long pgd_t;
typedef unsigned long pgprot_t;
struct page;
extern void clear_pages(void *page, int order);
static inline __attribute__((always_inline)) void clear_page(void *page) { clear_pages(page, 0); }
extern void copy_page(void *to, void *from);
extern void clear_user_page(void *page, unsigned long vaddr, struct page *pg);
extern void copy_user_page(void *to, void *from, unsigned long vaddr,
      struct page *pg);
extern __inline__ __attribute__((always_inline)) int get_order(unsigned long size)
{
 int lz;
 size = (size-1) >> 12;
 asm ("cntlzw %0,%1" : "=r" (lz) : "r" (size));
 return 32 - lz;
}
typedef unsigned long phys_addr_t;
typedef unsigned long mm_context_t;
typedef struct _PTE {
 unsigned long v:1;
 unsigned long vsid:24;
 unsigned long h:1;
 unsigned long api:6;
 unsigned long rpn:20;
 unsigned long :3;
 unsigned long r:1;
 unsigned long c:1;
 unsigned long w:1;
 unsigned long i:1;
 unsigned long m:1;
 unsigned long g:1;
 unsigned long :1;
 unsigned long pp:2;
} PTE;
typedef struct _SEGREG {
 unsigned long t:1;
 unsigned long ks:1;
 unsigned long kp:1;
 unsigned long n:1;
 unsigned long :4;
 unsigned long vsid:24;
} SEGREG;
typedef struct _P601_BATU {
 unsigned long bepi:15;
 unsigned long :8;
 unsigned long w:1;
 unsigned long i:1;
 unsigned long m:1;
 unsigned long ks:1;
 unsigned long kp:1;
 unsigned long pp:2;
} P601_BATU;
typedef struct _BATU {
 unsigned long bepi:15;
 unsigned long :4;
 unsigned long bl:11;
 unsigned long vs:1;
 unsigned long vp:1;
} BATU;
typedef struct _P601_BATL {
 unsigned long brpn:15;
 unsigned long :10;
 unsigned long v:1;
 unsigned long bl:6;
} P601_BATL;
typedef struct _BATL {
 unsigned long brpn:15;
 unsigned long :10;
 unsigned long w:1;
 unsigned long i:1;
 unsigned long m:1;
 unsigned long g:1;
 unsigned long :1;
 unsigned long pp:2;
} BATL;
typedef struct _BAT {
 BATU batu;
 BATL batl;
} BAT;
typedef struct _P601_BAT {
 P601_BATU batu;
 P601_BATL batl;
} P601_BAT;
typedef unsigned long cputime_t;
typedef u64 cputime64_t;
extern void cpu_idle(void);
static inline __attribute__((always_inline)) void smp_send_reschedule(int cpu) { }
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;
};
struct ipc64_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 long seq;
 unsigned int __pad2;
 unsigned long long __unused1;
 unsigned long long __unused2;
};
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;
};
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;
};
struct semid64_ds {
 struct ipc64_perm sem_perm;
 unsigned int __unused1;
 __kernel_time_t sem_otime;
 unsigned int __unused2;
 __kernel_time_t sem_ctime;
 unsigned long sem_nsems;
 unsigned long __unused3;
 unsigned long __unused4;
};
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;
};
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;
 int alter;
};
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;
};
static inline __attribute__((always_inline)) int copy_semundo(unsigned long clone_flags, struct task_struct *tsk)
{
 return 0;
}
static inline __attribute__((always_inline)) void exit_sem(struct task_struct *tsk)
{
 return;
}
struct siginfo;
typedef unsigned long old_sigset_t;
typedef struct {
 unsigned long sig[(64 / 32)];
} sigset_t;
typedef void __signalfn_t(int);
typedef __signalfn_t *__sighandler_t;
typedef void __restorefn_t(void);
typedef __restorefn_t *__sigrestore_t;
struct old_sigaction {
 __sighandler_t sa_handler;
 old_sigset_t sa_mask;
 unsigned long sa_flags;
 __sigrestore_t sa_restorer;
};
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;
struct sigcontext {
 unsigned long _unused[4];
 int signal;
 unsigned long handler;
 unsigned long oldmask;
 struct pt_regs *regs;
};
struct sig_dbg_op {
 int dbg_type;
 unsigned long dbg_value;
};
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;
};
typedef union sigval {
 int sival_int;
 void *sival_ptr;
} sigval_t;
typedef struct siginfo {
 int si_signo;
 int si_errno;
 int si_code;
 union {
  int _pad[((128 - (3 * 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;
typedef struct sigevent {
 sigval_t sigev_value;
 int sigev_signo;
 int sigev_notify;
 union {
  int _pad[((64/sizeof(int)) - 3)];
   int _tid;
  struct {
   void (*_function)(sigval_t);
   void *_attribute;
  } _sigev_thread;
 } _sigev_un;
} sigevent_t;
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)
  memcpy(to, from, sizeof(*to));
 else
  memcpy(to, from, (3 * sizeof(int)) + sizeof(from->_sifields._sigchld));
}
extern int copy_siginfo_to_user(struct siginfo *to, struct siginfo *from);
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;
};
static inline __attribute__((always_inline)) void sigaddset(sigset_t *set, int _sig)
{
 unsigned long sig = _sig - 1;
 if ((64 / 32) == 1)
  set->sig[0] |= 1UL << sig;
 else
  set->sig[sig / 32] |= 1UL << (sig % 32);
}
static inline __attribute__((always_inline)) void sigdelset(sigset_t *set, int _sig)
{
 unsigned long sig = _sig - 1;
 if ((64 / 32) == 1)
  set->sig[0] &= ~(1UL << sig);
 else
  set->sig[sig / 32] &= ~(1UL << (sig % 32));
}
static inline __attribute__((always_inline)) int sigismember(sigset_t *set, int _sig)
{
 unsigned long sig = _sig - 1;
 if ((64 / 32) == 1)
  return 1 & (set->sig[0] >> sig);
 else
  return 1 & (set->sig[sig / 32] >> (sig % 32));
}
static inline __attribute__((always_inline)) int sigfindinword(unsigned long word)
{
 return ffz(~word);
}
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 / 32)) { 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 / 32)) { 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 / 32)) { 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 signotset(sigset_t *set) { extern void _NSIG_WORDS_is_unsupported_size(void); switch ((64 / 32)) { 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 / 32)) {
 default:
  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 / 32)) {
 default:
  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 / 32)) {
 default:
  memset(&set->sig[1], 0, sizeof(long)*((64 / 32)-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 / 32)) {
 default:
  memset(&set->sig[1], -1, sizeof(long)*((64 / 32)-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);
extern unsigned securebits;
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 *);
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 int wait_for_completion_interruptible(struct completion *x);
extern unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout);
extern unsigned long wait_for_completion_interruptible_timeout( struct completion *x, unsigned long timeout);
extern void complete(struct completion *);
extern void complete_all(struct completion *);
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;
};
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);
typedef struct kmem_cache_s kmem_cache_t;
struct free_area {
 struct list_head free_list;
 unsigned long nr_free;
};
struct pglist_data;
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];
} ;
struct zone {
 unsigned long free_pages;
 unsigned long pages_min, pages_low, pages_high;
 unsigned long lowmem_reserve[3];
 struct per_cpu_pageset pageset[1];
 spinlock_t lock;
 struct free_area free_area[11];
 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;
 unsigned long pages_scanned;
 int all_unreclaimable;
 int temp_priority;
 int prev_priority;
 wait_queue_head_t * wait_table;
 unsigned long wait_table_size;
 unsigned long wait_table_bits;
 struct pglist_data *zone_pgdat;
 struct page *zone_mem_map;
 unsigned long zone_start_pfn;
 unsigned long spanned_pages;
 unsigned long present_pages;
 char *name;
} ;
struct zonelist {
 struct zone *zones[(1 << 0) * 3 + 1];
};
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;
 int kswapd_max_order;
} pg_data_t;
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, int order);
int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
  int alloc_type, int can_try_harder, int gfp_high);
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;
}
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 zone == zone->zone_pgdat->node_zones + 2;
}
static inline __attribute__((always_inline)) int is_normal(struct zone *zone)
{
 return zone == zone->zone_pgdat->node_zones + 1;
}
struct ctl_table;
struct file;
int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
extern int sysctl_lowmem_reserve_ratio[3 -1];
int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
extern struct pglist_data contig_page_data;
struct vm_area_struct;
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,
  (&contig_page_data)->node_zonelists + (gfp_mask & 0x03));
}
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);
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[];
struct obs_kernel_param {
 const char *str;
 int (*setup_func)(char *);
 int early;
};
void __attribute__ ((__section__ (".init.text"))) parse_early_param(void);
extern void __attribute__ ((__section__ (".init.text"))) 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);
static inline __attribute__((always_inline)) void *kmem_cache_alloc_node(kmem_cache_t *cachep, int node)
{
 return kmem_cache_alloc(cachep, (0x10 | 0x40 | 0x80));
}
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;
 if (size <= 32) goto found; else i++;
 if (size <= 64) goto found; else i++;
 if (size <= 96) goto found; else i++;
 if (size <= 128) goto found; else i++;
 if (size <= 192) 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++;
  {
   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 *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;
static inline __attribute__((always_inline)) void *__alloc_percpu(size_t size, size_t align)
{
 void *ret = kmalloc(size, (0x10 | 0x40 | 0x80));
 if (ret)
  memset(ret, 0, size);
 return ret;
}
static inline __attribute__((always_inline)) void free_percpu(const void *ptr)
{
 kfree(ptr);
}
struct exec_domain;
extern unsigned long avenrun[];
extern unsigned long total_forks;
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);
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;
};
static inline __attribute__((always_inline)) void init_timer(struct timer_list * timer)
{
 timer->base = ((void *)0);
 timer->magic = 0x4b87ad6e;
 do { (void)(&timer->lock); } while(0);
}
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);
static inline __attribute__((always_inline)) void add_timer(struct timer_list * timer)
{
 __mod_timer(timer, timer->expires);
}
extern void init_timers(void);
extern void run_local_timers(void);
extern void it_real_fn(unsigned long);
struct sched_param {
 int sched_priority;
};
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(void);
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;
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;
};
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(&work->timer);
 if (ret)
  clear_bit(0, &work->pending);
 return ret;
}
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;
};
struct kioctx;
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 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);
struct kioctx *lookup_ioctx(unsigned long ctx_id);
extern atomic_t aio_nr;
extern unsigned aio_max_nr;
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, anon_rss, total_vm, locked_vm, shared_vm;
 unsigned long exec_vm, stack_vm, reserved_vm, def_flags, nr_ptes;
 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;
 unsigned long hiwater_rss;
 unsigned long hiwater_vm;
};
struct sighand_struct {
 atomic_t count;
 struct k_sigaction action[64];
 spinlock_t siglock;
};
struct signal_struct {
 atomic_t count;
 atomic_t live;
 wait_queue_head_t wait_chldexit;
 task_t *curr_target;
 struct sigpending shared_pending;
 int group_exit_code;
 struct task_struct *group_exit_task;
 int notify_count;
 int group_stop_count;
 unsigned int flags;
 struct list_head posix_timers;
 pid_t pgrp;
 pid_t tty_old_pgrp;
 pid_t session;
 int leader;
 struct tty_struct *tty;
 cputime_t utime, stime, cutime, cstime;
 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
 struct rlimit rlim[13];
};
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;
enum idle_type
{
 SCHED_IDLE,
 NOT_IDLE,
 NEWLY_IDLE,
 MAX_IDLE_TYPES
};
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];
};
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;
 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;
 long exit_state;
 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];
 struct completion *vfork_done;
 int *set_child_tid;
 int *clear_child_tid;
 unsigned long rt_priority;
 unsigned long it_real_value, it_real_incr;
 cputime_t it_virt_value, it_virt_incr;
 cputime_t it_prof_value, it_prof_incr;
 struct timer_list real_timer;
 cputime_t 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;
 int oomkilladj;
 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;
 u64 rchar, wchar, syscr, syscw;
};
static inline __attribute__((always_inline)) pid_t process_group(struct task_struct *tsk)
{
 return tsk->signal->pgrp;
}
static inline __attribute__((always_inline)) int pid_alive(struct task_struct *p)
{
 return p->pids[PIDTYPE_PID].nr != 0;
}
extern void free_task(struct task_struct *tsk);
extern void __put_task_struct(struct task_struct *tsk);
static inline __attribute__((always_inline)) int set_cpus_allowed(task_t *p, cpumask_t new_mask)
{
 if (!__cpus_intersects(&(new_mask), &(cpu_online_map), 1))
  return -22;
 return 0;
}
extern unsigned long long sched_clock(void);
static inline __attribute__((always_inline)) void idle_task_exit(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);
extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
extern task_t *idle_task(int cpu);
void yield(void);
extern struct exec_domain default_exec_domain;
union thread_union {
 struct thread_info thread_info;
 unsigned long stack[8192/sizeof(long)];
};
static inline __attribute__((always_inline)) int kstack_end(void *addr)
{
 return !(((unsigned long)addr+sizeof(void*)-1) & (8192 -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 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);
 static inline __attribute__((always_inline)) 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;
 do { local_irq_save_ptr(&flags); do { } while (0); do { (void)(&tsk->sighand->siglock); } while(0); (void)0; } while (0);
 ret = dequeue_signal(tsk, mask, info);
 do { do { (void)(&tsk->sighand->siglock); } while(0); asm volatile("mtmsr %0" : : "r" (flags)); do { } while (0); (void)0; } while (0);
 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_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);
static inline __attribute__((always_inline)) int on_sig_stack(unsigned long sp)
{
 return (sp - current->sas_ss_sp < current->sas_ss_size);
}
static inline __attribute__((always_inline)) int sas_ss_flags(unsigned long sp)
{
 return (current->sas_ss_size == 0 ? 2
  : on_sig_stack(sp) ? 1 : 0);
}
static inline __attribute__((always_inline)) int capable(int cap)
{
 if (((current->cap_effective) & (1 << (cap)))) {
  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_return((&mm->mm_count)) == 0))
  __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 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);
static inline __attribute__((always_inline)) void task_lock(struct task_struct *p)
{
 do { do { } while (0); do { (void)(&p->alloc_lock); } while(0); (void)0; } while(0);
}
static inline __attribute__((always_inline)) void task_unlock(struct task_struct *p)
{
 do { do { (void)(&p->alloc_lock); } while(0); do { } while (0); (void)0; } while (0);
}
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 int cond_resched(void);
extern int cond_resched_lock(spinlock_t * lock);
extern int cond_resched_softirq(void);
static inline __attribute__((always_inline)) int lock_need_resched(spinlock_t *lock)
{
 if (0 || need_resched())
  return 1;
 return 0;
}
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 0;
}
static inline __attribute__((always_inline)) void set_task_cpu(struct task_struct *p, unsigned int cpu)
{
}
static inline __attribute__((always_inline)) void arch_pick_mmap_layout(struct mm_struct *mm)
{
 mm->mmap_base = ((0x80000000) / 8 * 3);
 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);
static inline __attribute__((always_inline)) void refrigerator(unsigned long flag) {}
static inline __attribute__((always_inline)) int freeze_processes(void) { do { __asm__ __volatile__( "1:	twi 31,0,0\n" ".section __bug_table,\"a\"\n\t" "	.long 1b,%0,%1,%2\n" ".previous" : : "i" (1209), "i" ("include/linux/sched.h"), "i" ((__func__))); } while (0); return 0; }
static inline __attribute__((always_inline)) void thaw_processes(void) {}
static inline __attribute__((always_inline)) int try_to_freeze(unsigned long refrigerator_flags)
{
 return 0;
}
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 long st_size;
 unsigned long st_atime;
 unsigned long st_mtime;
 unsigned long st_ctime;
};
struct stat {
 unsigned st_dev;
 ino_t st_ino;
 mode_t st_mode;
 nlink_t st_nlink;
 uid_t st_uid;
 gid_t st_gid;
 unsigned st_rdev;
 off_t st_size;
 unsigned long st_blksize;
 unsigned 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;
 unsigned long __unused4;
 unsigned long __unused5;
};
struct stat64 {
 unsigned long long st_dev;
 unsigned long long st_ino;
 unsigned int st_mode;
 unsigned int st_nlink;
 unsigned int st_uid;
 unsigned int st_gid;
 unsigned long long st_rdev;
 unsigned short int __pad2;
 long long st_size;
 long st_blksize;
 long long st_blocks;
 long st_atime;
 unsigned long st_atime_nsec;
 long st_mtime;
 unsigned long int st_mtime_nsec;
 long st_ctime;
 unsigned long int st_ctime_nsec;
 unsigned long int __unused4;
 unsigned long int __unused5;
};
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;
};
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);
typedef unsigned long elf_greg_t;
typedef elf_greg_t elf_gregset_t[48];
typedef double elf_fpreg_t;
typedef elf_fpreg_t elf_fpregset_t[33];
typedef __vector128 elf_vrreg_t;
typedef elf_vrreg_t elf_vrregset_t[33];
struct task_struct;
extern int dump_task_fpu(struct task_struct *t, elf_fpregset_t *fpu);
extern int dcache_bsize;
extern int icache_bsize;
extern int ucache_bsize;
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;
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;
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;
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;
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;
extern Elf32_Dyn _DYNAMIC [];
struct kobject;
struct module;
struct attribute {
 char * name;
 struct module * owner;
 mode_t mode;
};
struct attribute_group {
 char * name;
 struct attribute ** attrs;
};
struct vm_area_struct;
struct bin_attribute {
 struct attribute attr;
 size_t size;
 void *private;
 ssize_t (*read)(struct kobject *, char *, loff_t, size_t);
 ssize_t (*write)(struct kobject *, char *, loff_t, size_t);
 int (*mmap)(struct kobject *, struct bin_attribute *attr,
      struct vm_area_struct *vma);
};
struct sysfs_ops {
 ssize_t (*show)(struct kobject *, struct attribute *,char *);
 ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
};
struct sysfs_dirent {
 atomic_t s_count;
 struct list_head s_sibling;
 struct list_head s_children;
 void * s_element;
 int s_type;
 umode_t s_mode;
 struct dentry * s_dentry;
};
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 *);
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));
extern char hotplug_path[];
typedef int kobject_action_t;
enum kobject_action {
 KOBJ_ADD = ( kobject_action_t) 0x01,
 KOBJ_REMOVE = ( kobject_action_t) 0x02,
 KOBJ_CHANGE = ( kobject_action_t) 0x03,
 KOBJ_MOUNT = ( kobject_action_t) 0x04,
 KOBJ_UMOUNT = ( kobject_action_t) 0x05,
 KOBJ_OFFLINE = ( kobject_action_t) 0x06,
 KOBJ_ONLINE = ( kobject_action_t) 0x07,
};
static inline __attribute__((always_inline)) int kobject_uevent(struct kobject *kobj,
     enum kobject_action action,
     struct attribute *attr)
{
 return 0;
}
static inline __attribute__((always_inline)) int kobject_uevent_atomic(struct kobject *kobj,
            enum kobject_action action,
     struct attribute *attr)
{
 return 0;
}
extern u64 hotplug_seqnum;
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 char * kobject_get_path(struct kobject *, int);
struct kobj_type {
 void (*release)(struct kobject *);
 struct sysfs_ops * sysfs_ops;
 struct attribute ** default_attrs;
};
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 *);
struct subsystem {
 struct kset kset;
 struct rw_semaphore rwsem;
};
extern struct subsystem kernel_subsys;
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 *);
static inline __attribute__((always_inline)) void kobject_hotplug(struct kobject *kobj, enum kobject_action action) { }
static inline __attribute__((always_inline)) int add_hotplug_env_var(char **envp, int num_envp, int *cur_index,
          char *buffer, int buffer_size, int *cur_len,
          const char *format, ...)
{ return 0; }
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;
};
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);
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);
struct module;
extern int module_param_sysfs_setup(struct module *mod,
        struct kernel_param *kparam,
        unsigned int num_params);
extern void module_param_sysfs_remove(struct module *mod);
extern unsigned long m68k_machtype;
extern unsigned long m68k_cputype;
extern unsigned long m68k_fputype;
extern unsigned long m68k_mmutype;
extern int m68k_is040or060;
extern int num_memory;
extern int m68k_realnum_memory;
struct mem_info {
 unsigned long addr;
 unsigned long size;
};
extern struct mem_info memory[4];
struct pt_regs;
struct pci_bus;
struct pci_dev;
struct seq_file;
struct machdep_calls {
 void (*setup_arch)(void);
 int (*show_cpuinfo)(struct seq_file *m);
 int (*show_percpuinfo)(struct seq_file *m, int i);
 unsigned int (*irq_canonicalize)(unsigned int irq);
 void (*init_IRQ)(void);
 int (*get_irq)(struct pt_regs *);
 void (*init)(void);
 void (*restart)(char *cmd);
 void (*power_off)(void);
 void (*halt)(void);
 void (*idle)(void);
 void (*power_save)(void);
 long (*time_init)(void);
 int (*set_rtc_time)(unsigned long nowtime);
 unsigned long (*get_rtc_time)(void);
 unsigned char (*rtc_read_val)(int addr);
 void (*rtc_write_val)(int addr, unsigned char val);
 void (*calibrate_decr)(void);
 void (*heartbeat)(void);
 unsigned long heartbeat_reset;
 unsigned long heartbeat_count;
 unsigned long (*find_end_of_memory)(void);
 void (*setup_io_mappings)(void);
 void (*early_serial_map)(void);
   void (*progress)(char *, unsigned short);
 void (*kgdb_map_scc)(void);
 unsigned char (*nvram_read_val)(int addr);
 void (*nvram_write_val)(int addr, unsigned char val);
 void (*nvram_sync)(void);
 void (*pcibios_fixup)(void);
 void (*pcibios_fixup_resources)(struct pci_dev *);
 void (*pcibios_fixup_bus)(struct pci_bus *);
 int (*pcibios_enable_device_hook)(struct pci_dev *, int initial);
 unsigned char (*pci_swizzle)(struct pci_dev *, unsigned char *);
 int (*pci_map_irq)(struct pci_dev *, unsigned char, unsigned char);
 int (*pci_exclude_device)(unsigned char, unsigned char);
 void (*pcibios_after_init)(void);
 int ppc_machine;
 long (*feature_call)(unsigned int feature, ...);
};
extern struct machdep_calls ppc_md;
extern char cmd_line[512];
extern void setup_pci_ptrs(void);
typedef enum sys_ctrler_kind {
 SYS_CTRLER_UNKNOWN = 0,
 SYS_CTRLER_CUDA = 1,
 SYS_CTRLER_PMU = 2,
} sys_ctrler_t;
extern sys_ctrler_t sys_ctrler;
static __inline__ __attribute__((always_inline)) int irq_canonicalize(int irq)
{
 if (ppc_md.irq_canonicalize)
  return ppc_md.irq_canonicalize(irq);
 return irq;
}
extern unsigned long ppc_cached_irq_mask[((256 + 31) / 32)];
extern unsigned long ppc_lost_interrupts[((256 + 31) / 32)];
extern atomic_t ppc_n_lost_interrupts;
struct irqaction;
struct pt_regs;
int handle_IRQ_event(unsigned int, struct pt_regs *, struct irqaction *);
typedef struct {
 unsigned long __softirq_pending;
 unsigned int __last_jiffy_stamp;
} __attribute__((__aligned__(32))) irq_cpustat_t;
extern irq_cpustat_t irq_stat[];
static inline __attribute__((always_inline)) void ack_bad_irq(int irq)
{
 printk("<2>" "illegal vector %d received!\n", irq);
 do { __asm__ __volatile__( "1:	twi 31,0,0\n" ".section __bug_table,\"a\"\n\t" "	.long 1b,%0,%1,%2\n" ".previous" : : "i" (27), "i" ("include/asm/hardirq.h"), "i" ((__func__))); } while (0);
}
static inline __attribute__((always_inline)) void account_user_vtime(struct task_struct *tsk)
{
}
static inline __attribute__((always_inline)) void account_system_vtime(struct task_struct *tsk)
{
}
extern void irq_exit(void);
typedef struct
{
 atomic_t a;
} local_t;
struct ppc_plt_entry
{
 unsigned int jump[4];
};
struct mod_arch_specific
{
 unsigned int core_plt_section, init_plt_section;
 struct list_head bug_list;
 struct bug_entry *bug_table;
 unsigned int num_bugs;
};
extern struct bug_entry *module_find_bug(unsigned long bugaddr);
struct kernel_symbol
{
 unsigned long value;
 const char *name;
};
struct modversion_info
{
 unsigned long crc;
 char name[(64 - sizeof(unsigned long))];
};
struct module;
struct module_attribute {
        struct attribute attr;
        ssize_t (*show)(struct module_attribute *, struct module *, char *);
        ssize_t (*store)(struct module_attribute *, struct module *,
    const char *, size_t count);
};
struct module_kobject
{
 struct kobject kobj;
 struct module *mod;
};
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);
extern struct subsystem module_subsys;
const struct exception_table_entry *search_exception_tables(unsigned long add);
struct notifier_block;
static inline __attribute__((always_inline)) const struct exception_table_entry *
search_module_extables(unsigned long addr)
{
 return ((void *)0);
}
static inline __attribute__((always_inline)) struct module *module_text_address(unsigned long addr)
{
 return ((void *)0);
}
static inline __attribute__((always_inline)) struct module *__module_text_address(unsigned long addr)
{
 return ((void *)0);
}
static inline __attribute__((always_inline)) void __module_get(struct module *module)
{
}
static inline __attribute__((always_inline)) int try_module_get(struct module *module)
{
 return 1;
}
static inline __attribute__((always_inline)) void module_put(struct module *module)
{
}
static inline __attribute__((always_inline)) const char *module_address_lookup(unsigned long addr,
      unsigned long *symbolsize,
      unsigned long *offset,
      char **modname)
{
 return ((void *)0);
}
static inline __attribute__((always_inline)) struct module *module_get_kallsym(unsigned int symnum,
      unsigned long *value,
      char *type,
      char namebuf[128])
{
 return ((void *)0);
}
static inline __attribute__((always_inline)) unsigned long module_kallsyms_lookup_name(const char *name)
{
 return 0;
}
static inline __attribute__((always_inline)) int is_exported(const char *name, const struct module *mod)
{
 return 0;
}
static inline __attribute__((always_inline)) int register_module_notifier(struct notifier_block * nb)
{
 return 0;
}
static inline __attribute__((always_inline)) int unregister_module_notifier(struct notifier_block * nb)
{
 return 0;
}
static inline __attribute__((always_inline)) void print_modules(void)
{
}
struct device_driver;
struct module;
static inline __attribute__((always_inline)) void module_add_driver(struct module *module, struct device_driver *driver)
{
}
static inline __attribute__((always_inline)) void module_remove_driver(struct device_driver *driver)
{
}
struct obsolete_modparm {
 char name[64];
 char type[64-sizeof(void *)];
 void *addr;
};
static inline __attribute__((always_inline)) void MODULE_PARM_(void) { }
extern void __attribute__((deprecated)) inter_module_register(const char *,
  struct module *, const void *);
extern void __attribute__((deprecated)) inter_module_unregister(const char *);
extern const void * __attribute__((deprecated)) inter_module_get(const char *);
extern const void * __attribute__((deprecated)) inter_module_get_request(const char *,
  const char *);
extern void __attribute__((deprecated)) inter_module_put(const char *);
struct flock {
 short l_type;
 short l_whence;
 off_t l_start;
 off_t l_len;
 pid_t l_pid;
};
struct flock64 {
 short l_type;
 short l_whence;
 loff_t l_start;
 loff_t l_len;
 pid_t l_pid;
};
extern unsigned int __invalid_size_argument_for_IOC;
struct rand_pool_info {
 int entropy_count;
 int buf_size;
 __u32 buf[0];
};
extern void rand_initialize_irq(int irq);
extern void add_input_randomness(unsigned int type, unsigned int code,
     unsigned int value);
extern void add_interrupt_randomness(int irq);
extern void get_random_bytes(void *buf, int nbytes);
void generate_random_uuid(unsigned char uuid_out[16]);
extern __u32 secure_ip_id(__u32 daddr);
extern u32 secure_tcp_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport);
extern __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
     __u16 sport, __u16 dport);
extern __u32 secure_tcp_syn_cookie(__u32 saddr, __u32 daddr,
       __u16 sport, __u16 dport,
       __u32 sseq, __u32 count,
       __u32 data);
extern __u32 check_tcp_syn_cookie(__u32 cookie, __u32 saddr,
      __u32 daddr, __u16 sport,
      __u16 dport, __u32 sseq,
      __u32 count, __u32 maxdiff);
extern __u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr,
       __u16 sport, __u16 dport);
extern struct file_operations random_fops, urandom_fops;
struct pollfd {
 int fd;
 short events;
 short revents;
};
struct raw_prio_tree_node {
 struct prio_tree_node *left;
 struct prio_tree_node *right;
 struct prio_tree_node *parent;
};
struct prio_tree_node {
 struct prio_tree_node *left;
 struct prio_tree_node *right;
 struct prio_tree_node *parent;
 unsigned long start;
 unsigned long last;
};
struct prio_tree_root {
 struct prio_tree_node *prio_tree_node;
 unsigned short index_bits;
 unsigned short raw;
};
struct prio_tree_iter {
 struct prio_tree_node *cur;
 unsigned long mask;
 unsigned long value;
 int size_level;
 struct prio_tree_root *root;
 unsigned long r_index;
 unsigned long h_index;
};
static inline __attribute__((always_inline)) void prio_tree_iter_init(struct prio_tree_iter *iter,
  struct prio_tree_root *root, unsigned long r_index, unsigned long h_index)
{
 iter->root = root;
 iter->r_index = r_index;
 iter->h_index = h_index;
 iter->cur = ((void *)0);
}
static inline __attribute__((always_inline)) int prio_tree_empty(const struct prio_tree_root *root)
{
 return root->prio_tree_node == ((void *)0);
}
static inline __attribute__((always_inline)) int prio_tree_root(const struct prio_tree_node *node)
{
 return node->parent == node;
}
static inline __attribute__((always_inline)) int prio_tree_left_empty(const struct prio_tree_node *node)
{
 return node->left == node;
}
static inline __attribute__((always_inline)) int prio_tree_right_empty(const struct prio_tree_node *node)
{
 return node->right == node;
}
struct prio_tree_node *prio_tree_replace(struct prio_tree_root *root,
                struct prio_tree_node *old, struct prio_tree_node *node);
struct prio_tree_node *prio_tree_insert(struct prio_tree_root *root,
                struct prio_tree_node *node);
void prio_tree_remove(struct prio_tree_root *root, struct prio_tree_node *node);
struct prio_tree_node *prio_tree_next(struct prio_tree_iter *iter);
struct files_stat_struct {
 int nr_files;
 int nr_free_files;
 int max_files;
};
extern struct files_stat_struct files_stat;
struct inodes_stat_t {
 int nr_inodes;
 int nr_unused;
 int dummy[5];
};
extern struct inodes_stat_t inodes_stat;
extern int leases_enable, lease_break_time;
extern int dir_notify_enable;
static inline __attribute__((always_inline)) int old_valid_dev(dev_t dev)
{
 return ((unsigned int) ((dev) >> 20)) < 256 && ((unsigned int) ((dev) & ((1U << 20) - 1))) < 256;
}
static inline __attribute__((always_inline)) u16 old_encode_dev(dev_t dev)
{
 return (((unsigned int) ((dev) >> 20)) << 8) | ((unsigned int) ((dev) & ((1U << 20) - 1)));
}
static inline __attribute__((always_inline)) dev_t old_decode_dev(u16 val)
{
 return ((((val >> 8) & 255) << 20) | (val & 255));
}
static inline __attribute__((always_inline)) int new_valid_dev(dev_t dev)
{
 return 1;
}
static inline __attribute__((always_inline)) u32 new_encode_dev(dev_t dev)
{
 unsigned major = ((unsigned int) ((dev) >> 20));
 unsigned minor = ((unsigned int) ((dev) & ((1U << 20) - 1)));
 return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
}
static inline __attribute__((always_inline)) dev_t new_decode_dev(u32 dev)
{
 unsigned major = (dev & 0xfff00) >> 8;
 unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
 return (((major) << 20) | (minor));
}
static inline __attribute__((always_inline)) int huge_valid_dev(dev_t dev)
{
 return 1;
}
static inline __attribute__((always_inline)) u64 huge_encode_dev(dev_t dev)
{
 return new_encode_dev(dev);
}
static inline __attribute__((always_inline)) dev_t huge_decode_dev(u64 dev)
{
 return new_decode_dev(dev);
}
static inline __attribute__((always_inline)) int sysv_valid_dev(dev_t dev)
{
 return ((unsigned int) ((dev) >> 20)) < (1<<14) && ((unsigned int) ((dev) & ((1U << 20) - 1))) < (1<<18);
}
static inline __attribute__((always_inline)) u32 sysv_encode_dev(dev_t dev)
{
 return ((unsigned int) ((dev) & ((1U << 20) - 1))) | (((unsigned int) ((dev) >> 20)) << 18);
}
static inline __attribute__((always_inline)) unsigned sysv_major(u32 dev)
{
 return (dev >> 18) & 0x3fff;
}
static inline __attribute__((always_inline)) unsigned sysv_minor(u32 dev)
{
 return dev & 0x3ffff;
}
struct rcu_head {
 struct rcu_head *next;
 void (*func)(struct rcu_head *head);
};
struct rcu_ctrlblk {
 long cur;
 long completed;
 int next_pending;
} ;
static inline __attribute__((always_inline)) int rcu_batch_before(long a, long b)
{
        return (a - b) < 0;
}
static inline __attribute__((always_inline)) int rcu_batch_after(long a, long b)
{
        return (a - b) > 0;
}
struct rcu_data {
 long quiescbatch;
 int passed_quiesc;
 int qs_pending;
 long batch;
 struct rcu_head *nxtlist;
 struct rcu_head **nxttail;
 struct rcu_head *curlist;
 struct rcu_head **curtail;
 struct rcu_head *donelist;
 struct rcu_head **donetail;
 int cpu;
};
extern __typeof__(struct rcu_data) per_cpu__rcu_data;
extern __typeof__(struct rcu_data) per_cpu__rcu_bh_data;
extern struct rcu_ctrlblk rcu_ctrlblk;
extern struct rcu_ctrlblk rcu_bh_ctrlblk;
static inline __attribute__((always_inline)) void rcu_qsctr_inc(int cpu)
{
 struct rcu_data *rdp = &(*((void)cpu, &per_cpu__rcu_data));
 rdp->passed_quiesc = 1;
}
static inline __attribute__((always_inline)) void rcu_bh_qsctr_inc(int cpu)
{
 struct rcu_data *rdp = &(*((void)cpu, &per_cpu__rcu_bh_data));
 rdp->passed_quiesc = 1;
}
static inline __attribute__((always_inline)) int __rcu_pending(struct rcu_ctrlblk *rcp,
      struct rcu_data *rdp)
{
 if (rdp->curlist && !rcu_batch_before(rcp->completed, rdp->batch))
  return 1;
 if (!rdp->curlist && rdp->nxtlist)
  return 1;
 if (rdp->donelist)
  return 1;
 if (rdp->quiescbatch != rcp->cur || rdp->qs_pending)
  return 1;
 return 0;
}
static inline __attribute__((always_inline)) int rcu_pending(int cpu)
{
 return __rcu_pending(&rcu_ctrlblk, &(*((void)cpu, &per_cpu__rcu_data))) ||
  __rcu_pending(&rcu_bh_ctrlblk, &(*((void)cpu, &per_cpu__rcu_bh_data)));
}
extern void rcu_init(void);
extern void rcu_check_callbacks(int cpu, int user);
extern void rcu_restart_cpu(int cpu);
extern void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *head));
extern void call_rcu_bh(struct rcu_head *head, void (*func)(struct rcu_head *head));
extern void synchronize_kernel(void);
struct nameidata;
struct vfsmount;
struct qstr {
 unsigned int hash;
 unsigned int len;
 const unsigned char *name;
};
struct dentry_stat_t {
 int nr_dentry;
 int nr_unused;
 int age_limit;
 int want_pages;
 int dummy[2];
};
extern struct dentry_stat_t dentry_stat;
static inline __attribute__((always_inline)) unsigned long
partial_name_hash(unsigned long c, unsigned long prevhash)
{
 return (prevhash + (c << 4) + (c >> 4)) * 11;
}
static inline __attribute__((always_inline)) unsigned long end_name_hash(unsigned long hash)
{
 return (unsigned int) hash;
}
static inline __attribute__((always_inline)) unsigned int
full_name_hash(const unsigned char *name, unsigned int len)
{
 unsigned long hash = 0;
 while (len--)
  hash = partial_name_hash(*name++, hash);
 return end_name_hash(hash);
}
struct dcookie_struct;
struct dentry {
 atomic_t d_count;
 unsigned int d_flags;
 spinlock_t d_lock;
 struct inode *d_inode;
 struct dentry *d_parent;
 struct qstr d_name;
 struct list_head d_lru;
 struct list_head d_child;
 struct list_head d_subdirs;
 struct list_head d_alias;
 unsigned long d_time;
 struct dentry_operations *d_op;
 struct super_block *d_sb;
 void *d_fsdata;
  struct rcu_head d_rcu;
 struct dcookie_struct *d_cookie;
 struct hlist_node d_hash;
 int d_mounted;
 unsigned char d_iname[36];
};
struct dentry_operations {
 int (*d_revalidate)(struct dentry *, struct nameidata *);
 int (*d_hash) (struct dentry *, struct qstr *);
 int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
 int (*d_delete)(struct dentry *);
 void (*d_release)(struct dentry *);
 void (*d_iput)(struct dentry *, struct inode *);
};
extern spinlock_t dcache_lock;
static inline __attribute__((always_inline)) void __d_drop(struct dentry *dentry)
{
 if (!(dentry->d_flags & 0x0010)) {
  dentry->d_flags |= 0x0010;
  hlist_del_rcu(&dentry->d_hash);
 }
}
static inline __attribute__((always_inline)) void d_drop(struct dentry *dentry)
{
 do { do { } while (0); do { (void)(&dcache_lock); } while(0); (void)0; } while(0);
  __d_drop(dentry);
 do { do { (void)(&dcache_lock); } while(0); do { } while (0); (void)0; } while (0);
}
static inline __attribute__((always_inline)) int dname_external(struct dentry *dentry)
{
 return dentry->d_name.name != dentry->d_iname;
}
extern void d_instantiate(struct dentry *, struct inode *);
extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
extern void d_delete(struct dentry *);
extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
extern struct dentry * d_alloc_anon(struct inode *);
extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
extern void shrink_dcache_sb(struct super_block *);
extern void shrink_dcache_parent(struct dentry *);
extern void shrink_dcache_anon(struct hlist_head *);
extern int d_invalidate(struct dentry *);
extern struct dentry * d_alloc_root(struct inode *);
extern void d_genocide(struct dentry *);
extern struct dentry *d_find_alias(struct inode *);
extern void d_prune_aliases(struct inode *);
extern int have_submounts(struct dentry *);
extern void d_rehash(struct dentry *);
static inline __attribute__((always_inline)) void d_add(struct dentry *entry, struct inode *inode)
{
 d_instantiate(entry, inode);
 d_rehash(entry);
}
static inline __attribute__((always_inline)) struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
{
 struct dentry *res;
 res = d_instantiate_unique(entry, inode);
 d_rehash(res != ((void *)0) ? res : entry);
 return res;
}
extern void d_move(struct dentry *, struct dentry *);
extern struct dentry * d_lookup(struct dentry *, struct qstr *);
extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
extern int d_validate(struct dentry *, struct dentry *);
extern char * d_path(struct dentry *, struct vfsmount *, char *, int);
static inline __attribute__((always_inline)) struct dentry *dget(struct dentry *dentry)
{
 if (dentry) {
  do { if (!__builtin_constant_p(!((&dentry->d_count)->counter)) || (!((&dentry->d_count)->counter))) { __asm__ __volatile__( "1:	twnei %0,0\n" ".section __bug_table,\"a\"\n\t" "	.long 1b,%1,%2,%3\n" ".previous" : : "r" (!((&dentry->d_count)->counter)), "i" (293), "i" ("include/linux/dcache.h"), "i" ((__func__))); } } while (0);
  atomic_inc(&dentry->d_count);
 }
 return dentry;
}
extern struct dentry * dget_locked(struct dentry *);
static inline __attribute__((always_inline)) int d_unhashed(struct dentry *dentry)
{
 return (dentry->d_flags & 0x0010);
}
static inline __attribute__((always_inline)) struct dentry *dget_parent(struct dentry *dentry)
{
 struct dentry *ret;
 do { do { } while (0); do { (void)(&dentry->d_lock); } while(0); (void)0; } while(0);
 ret = dget(dentry->d_parent);
 do { do { (void)(&dentry->d_lock); } while(0); do { } while (0); (void)0; } while (0);
 return ret;
}
extern void dput(struct dentry *);
static inline __attribute__((always_inline)) int d_mountpoint(struct dentry *dentry)
{
 return dentry->d_mounted;
}
extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
extern int sysctl_vfs_cache_pressure;
struct radix_tree_root {
 unsigned int height;
 int gfp_mask;
 struct radix_tree_node *rnode;
};
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);
}
struct audit_status {
 __u32 mask;
 __u32 enabled;
 __u32 failure;
 __u32 pid;
 __u32 rate_limit;
 __u32 backlog_limit;
 __u32 lost;
 __u32 backlog;
};
struct audit_rule {
 __u32 flags;
 __u32 action;
 __u32 field_count;
 __u32 mask[64];
 __u32 fields[64];
 __u32 values[64];
};
struct iovec;
struct nameidata;
struct pipe_inode_info;
struct poll_table_struct;
struct kstatfs;
struct vm_area_struct;
struct vfsmount;
extern void update_atime (struct inode *);
extern void __attribute__ ((__section__ (".init.text"))) inode_init(unsigned long);
extern void __attribute__ ((__section__ (".init.text"))) inode_init_early(void);
extern void __attribute__ ((__section__ (".init.text"))) mnt_init(unsigned long);
extern void __attribute__ ((__section__ (".init.text"))) files_init(unsigned long);
struct buffer_head;
typedef int (get_block_t)(struct inode *inode, sector_t iblock,
   struct buffer_head *bh_result, int create);
typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,
   unsigned long max_blocks,
   struct buffer_head *bh_result, int create);
typedef void (dio_iodone_t)(struct inode *inode, loff_t offset,
   ssize_t bytes, void *private);
struct iattr {
 unsigned int ia_valid;
 umode_t ia_mode;
 uid_t ia_uid;
 gid_t ia_gid;
 loff_t ia_size;
 struct timespec ia_atime;
 struct timespec ia_mtime;
 struct timespec ia_ctime;
 unsigned int ia_attr_flags;
};
typedef __kernel_uid32_t qid_t;
typedef __u64 qsize_t;
extern spinlock_t dq_data_lock;
struct if_dqblk {
 __u64 dqb_bhardlimit;
 __u64 dqb_bsoftlimit;
 __u64 dqb_curspace;
 __u64 dqb_ihardlimit;
 __u64 dqb_isoftlimit;
 __u64 dqb_curinodes;
 __u64 dqb_btime;
 __u64 dqb_itime;
 __u32 dqb_valid;
};
struct if_dqinfo {
 __u64 dqi_bgrace;
 __u64 dqi_igrace;
 __u32 dqi_flags;
 __u32 dqi_valid;
};
typedef struct fs_disk_quota {
 __s8 d_version;
 __s8 d_flags;
 __u16 d_fieldmask;
 __u32 d_id;
 __u64 d_blk_hardlimit;
 __u64 d_blk_softlimit;
 __u64 d_ino_hardlimit;
 __u64 d_ino_softlimit;
 __u64 d_bcount;
 __u64 d_icount;
 __s32 d_itimer;
 __s32 d_btimer;
 __u16 d_iwarns;
 __u16 d_bwarns;
 __s32 d_padding2;
 __u64 d_rtb_hardlimit;
 __u64 d_rtb_softlimit;
 __u64 d_rtbcount;
 __s32 d_rtbtimer;
 __u16 d_rtbwarns;
 __s16 d_padding3;
 char d_padding4[8];
} fs_disk_quota_t;
typedef struct fs_qfilestat {
 __u64 qfs_ino;
 __u64 qfs_nblks;
 __u32 qfs_nextents;
} fs_qfilestat_t;
typedef struct fs_quota_stat {
 __s8 qs_version;
 __u16 qs_flags;
 __s8 qs_pad;
 fs_qfilestat_t qs_uquota;
 fs_qfilestat_t qs_gquota;
 __u32 qs_incoredqs;
 __s32 qs_btimelimit;
 __s32 qs_itimelimit;
 __s32 qs_rtbtimelimit;
 __u16 qs_bwarnlimit;
 __u16 qs_iwarnlimit;
} fs_quota_stat_t;
struct v1_mem_dqinfo {
};
struct v2_mem_dqinfo {
 unsigned int dqi_blocks;
 unsigned int dqi_free_blk;
 unsigned int dqi_free_entry;
};
struct mem_dqblk {
 __u32 dqb_bhardlimit;
 __u32 dqb_bsoftlimit;
 qsize_t dqb_curspace;
 __u32 dqb_ihardlimit;
 __u32 dqb_isoftlimit;
 __u32 dqb_curinodes;
 time_t dqb_btime;
 time_t dqb_itime;
};
struct quota_format_type;
struct mem_dqinfo {
 struct quota_format_type *dqi_format;
 struct list_head dqi_dirty_list;
 unsigned long dqi_flags;
 unsigned int dqi_bgrace;
 unsigned int dqi_igrace;
 union {
  struct v1_mem_dqinfo v1_i;
  struct v2_mem_dqinfo v2_i;
 } u;
};
struct super_block;
extern void mark_info_dirty(struct super_block *sb, int type);
struct dqstats {
 int lookups;
 int drops;
 int reads;
 int writes;
 int cache_hits;
 int allocated_dquots;
 int free_dquots;
 int syncs;
};
extern struct dqstats dqstats;
struct dquot {
 struct hlist_node dq_hash;
 struct list_head dq_inuse;
 struct list_head dq_free;
 struct list_head dq_dirty;
 struct semaphore dq_lock;
 atomic_t dq_count;
 wait_queue_head_t dq_wait_unused;
 struct super_block *dq_sb;
 unsigned int dq_id;
 loff_t dq_off;
 unsigned long dq_flags;
 short dq_type;
 struct mem_dqblk dq_dqb;
};
struct quota_format_ops {
 int (*check_quota_file)(struct super_block *sb, int type);
 int (*read_file_info)(struct super_block *sb, int type);
 int (*write_file_info)(struct super_block *sb, int type);
 int (*free_file_info)(struct super_block *sb, int type);
 int (*read_dqblk)(struct dquot *dquot);
 int (*commit_dqblk)(struct dquot *dquot);
 int (*release_dqblk)(struct dquot *dquot);
};
struct dquot_operations {
 int (*initialize) (struct inode *, int);
 int (*drop) (struct inode *);
 int (*alloc_space) (struct inode *, qsize_t, int);
 int (*alloc_inode) (const struct inode *, unsigned long);
 int (*free_space) (struct inode *, qsize_t);
 int (*free_inode) (const struct inode *, unsigned long);
 int (*transfer) (struct inode *, struct iattr *);
 int (*write_dquot) (struct dquot *);
 int (*acquire_dquot) (struct dquot *);
 int (*release_dquot) (struct dquot *);
 int (*mark_dirty) (struct dquot *);
 int (*write_info) (struct super_block *, int);
};
struct quotactl_ops {
 int (*quota_on)(struct super_block *, int, int, char *);
 int (*quota_off)(struct super_block *, int);
 int (*quota_sync)(struct super_block *, int);
 int (*get_info)(struct super_block *, int, struct if_dqinfo *);
 int (*set_info)(struct super_block *, int, struct if_dqinfo *);
 int (*get_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
 int (*set_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
 int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
 int (*set_xstate)(struct super_block *, unsigned int, int);
 int (*get_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
 int (*set_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
};
struct quota_format_type {
 int qf_fmt_id;
 struct quota_format_ops *qf_ops;
 struct module *qf_owner;
 struct quota_format_type *qf_next;
};
struct quota_info {
 unsigned int flags;
 struct semaphore dqio_sem;
 struct semaphore dqonoff_sem;
 struct rw_semaphore dqptr_sem;
 struct inode *files[2];
 struct vfsmount *mnt[2];
 struct mem_dqinfo info[2];
 struct quota_format_ops *ops[2];
};
int mark_dquot_dirty(struct dquot *dquot);
int register_quota_format(struct quota_format_type *fmt);
void unregister_quota_format(struct quota_format_type *fmt);
struct quota_module_name {
 int qm_fmt_id;
 char *qm_mod_name;
};
struct page;
struct address_space;
struct writeback_control;
struct address_space_operations {
 int (*writepage)(struct page *page, struct writeback_control *wbc);
 int (*readpage)(struct file *, struct page *);
 int (*sync_page)(struct page *);
 int (*writepages)(struct address_space *, struct writeback_control *);
 int (*set_page_dirty)(struct page *page);
 int (*readpages)(struct file *filp, struct address_space *mapping,
   struct list_head *pages, unsigned nr_pages);
 int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
 int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
 sector_t (*bmap)(struct address_space *, sector_t);
 int (*invalidatepage) (struct page *, unsigned long);
 int (*releasepage) (struct page *, int);
};
struct backing_dev_info;
struct address_space {
 struct inode *host;
 struct radix_tree_root page_tree;
 spinlock_t tree_lock;
 unsigned int i_mmap_writable;
 struct prio_tree_root i_mmap;
 struct list_head i_mmap_nonlinear;
 spinlock_t i_mmap_lock;
 unsigned int truncate_count;
 unsigned long nrpages;
 unsigned long writeback_index;
 struct address_space_operations *a_ops;
 unsigned long flags;
 struct backing_dev_info *backing_dev_info;
 spinlock_t private_lock;
 struct list_head private_list;
 struct address_space *assoc_mapping;
} __attribute__((aligned(sizeof(long))));
struct block_device {
 dev_t bd_dev;
 struct inode * bd_inode;
 int bd_openers;
 struct semaphore bd_sem;
 struct semaphore bd_mount_sem;
 struct list_head bd_inodes;
 void * bd_holder;
 int bd_holders;
 struct block_device * bd_contains;
 unsigned bd_block_size;
 struct hd_struct * bd_part;
 unsigned bd_part_count;
 int bd_invalidated;
 struct gendisk * bd_disk;
 struct list_head bd_list;
 struct backing_dev_info *bd_inode_backing_dev_info;
 unsigned long bd_private;
};
int mapping_tagged(struct address_space *mapping, int tag);
static inline __attribute__((always_inline)) int mapping_mapped(struct address_space *mapping)
{
 return !prio_tree_empty(&mapping->i_mmap) ||
  !list_empty(&mapping->i_mmap_nonlinear);
}
static inline __attribute__((always_inline)) int mapping_writably_mapped(struct address_space *mapping)
{
 return mapping->i_mmap_writable != 0;
}
struct inode {
 struct hlist_node i_hash;
 struct list_head i_list;
 struct list_head i_sb_list;
 struct list_head i_dentry;
 unsigned long i_ino;
 atomic_t i_count;
 umode_t i_mode;
 unsigned int i_nlink;
 uid_t i_uid;
 gid_t i_gid;
 dev_t i_rdev;
 loff_t i_size;
 struct timespec i_atime;
 struct timespec i_mtime;
 struct timespec i_ctime;
 unsigned int i_blkbits;
 unsigned long i_blksize;
 unsigned long i_version;
 unsigned long i_blocks;
 unsigned short i_bytes;
 unsigned char i_sock;
 spinlock_t i_lock;
 struct semaphore i_sem;
 struct rw_semaphore i_alloc_sem;
 struct inode_operations *i_op;
 struct file_operations *i_fop;
 struct super_block *i_sb;
 struct file_lock *i_flock;
 struct address_space *i_mapping;
 struct address_space i_data;
 struct list_head i_devices;
 struct pipe_inode_info *i_pipe;
 struct block_device *i_bdev;
 struct cdev *i_cdev;
 int i_cindex;
 __u32 i_generation;
 unsigned long i_dnotify_mask;
 struct dnotify_struct *i_dnotify;
 unsigned long i_state;
 unsigned long dirtied_when;
 unsigned int i_flags;
 atomic_t i_writecount;
 void *i_security;
 union {
  void *generic_ip;
 } u;
};
static inline __attribute__((always_inline)) loff_t i_size_read(struct inode *inode)
{
 return inode->i_size;
}
static inline __attribute__((always_inline)) void i_size_write(struct inode *inode, loff_t i_size)
{
 inode->i_size = i_size;
}
static inline __attribute__((always_inline)) unsigned iminor(struct inode *inode)
{
 return ((unsigned int) ((inode->i_rdev) & ((1U << 20) - 1)));
}
static inline __attribute__((always_inline)) unsigned imajor(struct inode *inode)
{
 return ((unsigned int) ((inode->i_rdev) >> 20));
}
extern struct block_device *I_BDEV(struct inode *inode);
struct fown_struct {
 rwlock_t lock;
 int pid;
 uid_t uid, euid;
 void *security;
 int signum;
};
struct file_ra_state {
 unsigned long start;
 unsigned long size;
 unsigned long flags;
 unsigned long cache_hit;
 unsigned long prev_page;
 unsigned long ahead_start;
 unsigned long ahead_size;
 unsigned long ra_pages;
 unsigned long mmap_hit;
 unsigned long mmap_miss;
};
struct file {
 struct list_head f_list;
 struct dentry *f_dentry;
 struct vfsmount *f_vfsmnt;
 struct file_operations *f_op;
 atomic_t f_count;
 unsigned int f_flags;
 mode_t f_mode;
 int f_error;
 loff_t f_pos;
 struct fown_struct f_owner;
 unsigned int f_uid, f_gid;
 struct file_ra_state f_ra;
 size_t f_maxcount;
 unsigned long f_version;
 void *f_security;
 void *private_data;
 struct list_head f_ep_links;
 spinlock_t f_ep_lock;
 struct address_space *f_mapping;
};
extern spinlock_t files_lock;
typedef struct files_struct *fl_owner_t;
struct file_lock_operations {
 void (*fl_insert)(struct file_lock *);
 void (*fl_remove)(struct file_lock *);
 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 void (*fl_release_private)(struct file_lock *);
};
struct lock_manager_operations {
 int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
 void (*fl_notify)(struct file_lock *);
 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 void (*fl_release_private)(struct file_lock *);
 void (*fl_break)(struct file_lock *);
};
typedef u32 rpc_authflavor_t;
enum rpc_auth_flavors {
 RPC_AUTH_NULL = 0,
 RPC_AUTH_UNIX = 1,
 RPC_AUTH_SHORT = 2,
 RPC_AUTH_DES = 3,
 RPC_AUTH_KRB = 4,
 RPC_AUTH_GSS = 6,
 RPC_AUTH_MAXFLAVOR = 8,
 RPC_AUTH_GSS_KRB5 = 390003,
 RPC_AUTH_GSS_KRB5I = 390004,
 RPC_AUTH_GSS_KRB5P = 390005,
 RPC_AUTH_GSS_LKEY = 390006,
 RPC_AUTH_GSS_LKEYI = 390007,
 RPC_AUTH_GSS_LKEYP = 390008,
 RPC_AUTH_GSS_SPKM = 390009,
 RPC_AUTH_GSS_SPKMI = 390010,
 RPC_AUTH_GSS_SPKMP = 390011,
};
enum rpc_msg_type {
 RPC_CALL = 0,
 RPC_REPLY = 1
};
enum rpc_reply_stat {
 RPC_MSG_ACCEPTED = 0,
 RPC_MSG_DENIED = 1
};
enum rpc_accept_stat {
 RPC_SUCCESS = 0,
 RPC_PROG_UNAVAIL = 1,
 RPC_PROG_MISMATCH = 2,
 RPC_PROC_UNAVAIL = 3,
 RPC_GARBAGE_ARGS = 4,
 RPC_SYSTEM_ERR = 5
};
enum rpc_reject_stat {
 RPC_MISMATCH = 0,
 RPC_AUTH_ERROR = 1
};
enum rpc_auth_stat {
 RPC_AUTH_OK = 0,
 RPC_AUTH_BADCRED = 1,
 RPC_AUTH_REJECTEDCRED = 2,
 RPC_AUTH_BADVERF = 3,
 RPC_AUTH_REJECTEDVERF = 4,
 RPC_AUTH_TOOWEAK = 5,
 RPCSEC_GSS_CREDPROBLEM = 13,
 RPCSEC_GSS_CTXPROBLEM = 14
};
 enum nfs_stat {
 NFS_OK = 0,
 NFSERR_PERM = 1,
 NFSERR_NOENT = 2,
 NFSERR_IO = 5,
 NFSERR_NXIO = 6,
 NFSERR_EAGAIN = 11,
 NFSERR_ACCES = 13,
 NFSERR_EXIST = 17,
 NFSERR_XDEV = 18,
 NFSERR_NODEV = 19,
 NFSERR_NOTDIR = 20,
 NFSERR_ISDIR = 21,
 NFSERR_INVAL = 22,
 NFSERR_FBIG = 27,
 NFSERR_NOSPC = 28,
 NFSERR_ROFS = 30,
 NFSERR_MLINK = 31,
 NFSERR_OPNOTSUPP = 45,
 NFSERR_NAMETOOLONG = 63,
 NFSERR_NOTEMPTY = 66,
 NFSERR_DQUOT = 69,
 NFSERR_STALE = 70,
 NFSERR_REMOTE = 71,
 NFSERR_WFLUSH = 99,
 NFSERR_BADHANDLE = 10001,
 NFSERR_NOT_SYNC = 10002,
 NFSERR_BAD_COOKIE = 10003,
 NFSERR_NOTSUPP = 10004,
 NFSERR_TOOSMALL = 10005,
 NFSERR_SERVERFAULT = 10006,
 NFSERR_BADTYPE = 10007,
 NFSERR_JUKEBOX = 10008,
 NFSERR_SAME = 10009,
 NFSERR_DENIED = 10010,
 NFSERR_EXPIRED = 10011,
 NFSERR_LOCKED = 10012,
 NFSERR_GRACE = 10013,
 NFSERR_FHEXPIRED = 10014,
 NFSERR_SHARE_DENIED = 10015,
 NFSERR_WRONGSEC = 10016,
 NFSERR_CLID_INUSE = 10017,
 NFSERR_RESOURCE = 10018,
 NFSERR_MOVED = 10019,
 NFSERR_NOFILEHANDLE = 10020,
 NFSERR_MINOR_VERS_MISMATCH = 10021,
 NFSERR_STALE_CLIENTID = 10022,
 NFSERR_STALE_STATEID = 10023,
 NFSERR_OLD_STATEID = 10024,
 NFSERR_BAD_STATEID = 10025,
 NFSERR_BAD_SEQID = 10026,
 NFSERR_NOT_SAME = 10027,
 NFSERR_LOCK_RANGE = 10028,
 NFSERR_SYMLINK = 10029,
 NFSERR_RESTOREFH = 10030,
 NFSERR_LEASE_MOVED = 10031,
 NFSERR_ATTRNOTSUPP = 10032,
 NFSERR_NO_GRACE = 10033,
 NFSERR_RECLAIM_BAD = 10034,
 NFSERR_RECLAIM_CONFLICT = 10035,
 NFSERR_BAD_XDR = 10036,
 NFSERR_LOCKS_HELD = 10037,
 NFSERR_OPENMODE = 10038,
 NFSERR_BADOWNER = 10039,
 NFSERR_BADCHAR = 10040,
 NFSERR_BADNAME = 10041,
 NFSERR_BAD_RANGE = 10042,
 NFSERR_LOCK_NOTSUPP = 10043,
 NFSERR_OP_ILLEGAL = 10044,
 NFSERR_DEADLOCK = 10045,
 NFSERR_FILE_OPEN = 10046,
 NFSERR_ADMIN_REVOKED = 10047,
 NFSERR_CB_PATH_DOWN = 10048,
 NFSERR_REPLAY_ME = 10049
};
enum nfs_ftype {
 NFNON = 0,
 NFREG = 1,
 NFDIR = 2,
 NFBLK = 3,
 NFCHR = 4,
 NFLNK = 5,
 NFSOCK = 6,
 NFBAD = 7,
 NFFIFO = 8
};
struct nfs_fh {
 unsigned short size;
 unsigned char data[128];
};
static inline __attribute__((always_inline)) int nfs_compare_fh(const struct nfs_fh *a, const struct nfs_fh *b)
{
 return a->size != b->size || memcmp(a->data, b->data, a->size) != 0;
}
static inline __attribute__((always_inline)) void nfs_copy_fh(struct nfs_fh *target, const struct nfs_fh *source)
{
 target->size = source->size;
 memcpy(target->data, source->data, source->size);
}
enum nfs3_stable_how {
 NFS_UNSTABLE = 0,
 NFS_DATA_SYNC = 1,
 NFS_FILE_SYNC = 2
};
struct nlm_lockowner;
struct nfs_lock_info {
 u32 state;
 u32 flags;
 struct nlm_lockowner *owner;
};
struct file_lock {
 struct file_lock *fl_next;
 struct list_head fl_link;
 struct list_head fl_block;
 fl_owner_t fl_owner;
 unsigned int fl_pid;
 wait_queue_head_t fl_wait;
 struct file *fl_file;
 unsigned char fl_flags;
 unsigned char fl_type;
 loff_t fl_start;
 loff_t fl_end;
 struct fasync_struct * fl_fasync;
 unsigned long fl_break_time;
 struct file_lock_operations *fl_ops;
 struct lock_manager_operations *fl_lmops;
 union {
  struct nfs_lock_info nfs_fl;
 } fl_u;
};
extern struct list_head file_lock_list;
extern int fcntl_getlk(struct file *, struct flock *);
extern int fcntl_setlk(struct file *, unsigned int, struct flock *);
extern int fcntl_getlk64(struct file *, struct flock64 *);
extern int fcntl_setlk64(struct file *, unsigned int, struct flock64 *);
extern void send_sigio(struct fown_struct *fown, int fd, int band);
extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
extern int fcntl_getlease(struct file *filp);
extern void locks_init_lock(struct file_lock *);
extern void locks_copy_lock(struct file_lock *, struct file_lock *);
extern void locks_remove_posix(struct file *, fl_owner_t);
extern void locks_remove_flock(struct file *);
extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
extern int posix_lock_file(struct file *, struct file_lock *);
extern int posix_lock_file_wait(struct file *, struct file_lock *);
extern void posix_block_lock(struct file_lock *, struct file_lock *);
extern void posix_unblock_lock(struct file *, struct file_lock *);
extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
extern int __break_lease(struct inode *inode, unsigned int flags);
extern void lease_get_mtime(struct inode *, struct timespec *time);
extern int setlease(struct file *, long, struct file_lock **);
extern void remove_lease(struct file_lock *);
extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
extern void steal_locks(fl_owner_t from);
struct fasync_struct {
 int magic;
 int fa_fd;
 struct fasync_struct *fa_next;
 struct file *fa_file;
};
extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
extern void kill_fasync(struct fasync_struct **, int, int);
extern void __kill_fasync(struct fasync_struct *, int, int);
extern int f_setown(struct file *filp, unsigned long arg, int force);
extern void f_delown(struct file *filp);
extern int send_sigurg(struct fown_struct *fown);
extern struct list_head super_blocks;
extern spinlock_t sb_lock;
struct super_block {
 struct list_head s_list;
 dev_t s_dev;
 unsigned long s_blocksize;
 unsigned long s_old_blocksize;
 unsigned char s_blocksize_bits;
 unsigned char s_dirt;
 unsigned long long s_maxbytes;
 struct file_system_type *s_type;
 struct super_operations *s_op;
 struct dquot_operations *dq_op;
  struct quotactl_ops *s_qcop;
 struct export_operations *s_export_op;
 unsigned long s_flags;
 unsigned long s_magic;
 struct dentry *s_root;
 struct rw_semaphore s_umount;
 struct semaphore s_lock;
 int s_count;
 int s_syncing;
 int s_need_sync_fs;
 atomic_t s_active;
 void *s_security;
 struct xattr_handler **s_xattr;
 struct list_head s_inodes;
 struct list_head s_dirty;
 struct list_head s_io;
 struct hlist_head s_anon;
 struct list_head s_files;
 struct block_device *s_bdev;
 struct list_head s_instances;
 struct quota_info s_dquot;
 int s_frozen;
 wait_queue_head_t s_wait_unfrozen;
 char s_id[32];
 void *s_fs_info;
 struct semaphore s_vfs_rename_sem;
 u32 s_time_gran;
};
extern struct timespec current_fs_time(struct super_block *sb);
enum {
 SB_UNFROZEN = 0,
 SB_FREEZE_WRITE = 1,
 SB_FREEZE_TRANS = 2,
};
static inline __attribute__((always_inline)) void lock_super(struct super_block * sb)
{
 down(&sb->s_lock);
}
static inline __attribute__((always_inline)) void unlock_super(struct super_block * sb)
{
 up(&sb->s_lock);
}
extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
extern int vfs_mkdir(struct inode *, struct dentry *, int);
extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
extern int vfs_symlink(struct inode *, struct dentry *, const char *, int);
extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
extern int vfs_rmdir(struct inode *, struct dentry *);
extern int vfs_unlink(struct inode *, struct dentry *);
extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
extern void dentry_unhash(struct dentry *dentry);
int generic_osync_inode(struct inode *, struct address_space *, int);
typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
struct block_device_operations {
 int (*open) (struct inode *, struct file *);
 int (*release) (struct inode *, struct file *);
 int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
 long (*compat_ioctl) (struct file *, unsigned, unsigned long);
 int (*media_changed) (struct gendisk *);
 int (*revalidate_disk) (struct gendisk *);
 struct module *owner;
};
typedef struct {
 size_t written;
 size_t count;
 union {
  char * buf;
  void *data;
 } arg;
 int error;
} read_descriptor_t;
typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
struct file_operations {
 struct module *owner;
 loff_t (*llseek) (struct file *, loff_t, int);
 ssize_t (*read) (struct file *, char *, size_t, loff_t *);
 ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
 int (*readdir) (struct file *, void *, filldir_t);
 unsigned int (*poll) (struct file *, struct poll_table_struct *);
 int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 int (*mmap) (struct file *, struct vm_area_struct *);
 int (*open) (struct inode *, struct file *);
 int (*flush) (struct file *);
 int (*release) (struct inode *, struct file *);
 int (*fsync) (struct file *, struct dentry *, int datasync);
 int (*fasync) (int, struct file *, int);
 int (*lock) (struct file *, int, struct file_lock *);
 ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
 ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
 ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 int (*check_flags)(int);
 int (*dir_notify)(struct file *filp, unsigned long arg);
 int (*flock) (struct file *, int, struct file_lock *);
};
struct inode_operations {
 int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
 struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
 int (*link) (struct dentry *,struct inode *,struct dentry *);
 int (*unlink) (struct inode *,struct dentry *);
 int (*symlink) (struct inode *,struct dentry *,const char *);
 int (*mkdir) (struct inode *,struct dentry *,int);
 int (*rmdir) (struct inode *,struct dentry *);
 int (*mknod) (struct inode *,struct dentry *,int,dev_t);
 int (*rename) (struct inode *, struct dentry *,
   struct inode *, struct dentry *);
 int (*readlink) (struct dentry *, char *,int);
 int (*follow_link) (struct dentry *, struct nameidata *);
 void (*put_link) (struct dentry *, struct nameidata *);
 void (*truncate) (struct inode *);
 int (*permission) (struct inode *, int, struct nameidata *);
 int (*setattr) (struct dentry *, struct iattr *);
 int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
 ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 ssize_t (*listxattr) (struct dentry *, char *, size_t);
 int (*removexattr) (struct dentry *, const char *);
};
struct seq_file;
extern ssize_t vfs_read(struct file *, char *, size_t, loff_t *);
extern ssize_t vfs_write(struct file *, const char *, size_t, loff_t *);
extern ssize_t vfs_readv(struct file *, const struct iovec *,
  unsigned long, loff_t *);
extern ssize_t vfs_writev(struct file *, const struct iovec *,
  unsigned long, loff_t *);
struct super_operations {
    struct inode *(*alloc_inode)(struct super_block *sb);
 void (*destroy_inode)(struct inode *);
 void (*read_inode) (struct inode *);
    void (*dirty_inode) (struct inode *);
 int (*write_inode) (struct inode *, int);
 void (*put_inode) (struct inode *);
 void (*drop_inode) (struct inode *);
 void (*delete_inode) (struct inode *);
 void (*put_super) (struct super_block *);
 void (*write_super) (struct super_block *);
 int (*sync_fs)(struct super_block *sb, int wait);
 void (*write_super_lockfs) (struct super_block *);
 void (*unlockfs) (struct super_block *);
 int (*statfs) (struct super_block *, struct kstatfs *);
 int (*remount_fs) (struct super_block *, int *, char *);
 void (*clear_inode) (struct inode *);
 void (*umount_begin) (struct super_block *);
 int (*show_options)(struct seq_file *, struct vfsmount *);
 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
};
extern void __mark_inode_dirty(struct inode *, int);
static inline __attribute__((always_inline)) void mark_inode_dirty(struct inode *inode)
{
 __mark_inode_dirty(inode, (1 | 2 | 4));
}
static inline __attribute__((always_inline)) void mark_inode_dirty_sync(struct inode *inode)
{
 __mark_inode_dirty(inode, 1);
}
static inline __attribute__((always_inline)) void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
{
 update_atime(dentry->d_inode);
}
static inline __attribute__((always_inline)) void file_accessed(struct file *file)
{
 if (!(file->f_flags & 01000000))
  touch_atime(file->f_vfsmnt, file->f_dentry);
}
int sync_inode(struct inode *inode, struct writeback_control *wbc);
struct export_operations {
 struct dentry *(*decode_fh)(struct super_block *sb, __u32 *fh, int fh_len, int fh_type,
    int (*acceptable)(void *context, struct dentry *de),
    void *context);
 int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
    int connectable);
 int (*get_name)(struct dentry *parent, char *name,
   struct dentry *child);
 struct dentry * (*get_parent)(struct dentry *child);
 struct dentry * (*get_dentry)(struct super_block *sb, void *inump);
 struct dentry * (*find_exported_dentry)(
  struct super_block *sb, void *obj, void *parent,
  int (*acceptable)(void *context, struct dentry *de),
  void *context);
};
extern struct dentry *
find_exported_dentry(struct super_block *sb, void *obj, void *parent,
       int (*acceptable)(void *context, struct dentry *de),
       void *context);
struct file_system_type {
 const char *name;
 int fs_flags;
 struct super_block *(*get_sb) (struct file_system_type *, int,
           const char *, void *);
 void (*kill_sb) (struct super_block *);
 struct module *owner;
 struct file_system_type * next;
 struct list_head fs_supers;
};
struct super_block *get_sb_bdev(struct file_system_type *fs_type,
 int flags, const char *dev_name, void *data,
 int (*fill_super)(struct super_block *, void *, int));
struct super_block *get_sb_single(struct file_system_type *fs_type,
 int flags, void *data,
 int (*fill_super)(struct super_block *, void *, int));
struct super_block *get_sb_nodev(struct file_system_type *fs_type,
 int flags, void *data,
 int (*fill_super)(struct super_block *, void *, int));
void generic_shutdown_super(struct super_block *sb);
void kill_block_super(struct super_block *sb);
void kill_anon_super(struct super_block *sb);
void kill_litter_super(struct super_block *sb);
void deactivate_super(struct super_block *sb);
int set_anon_super(struct super_block *s, void *data);
struct super_block *sget(struct file_system_type *type,
   int (*test)(struct super_block *,void *),
   int (*set)(struct super_block *,void *),
   void *data);
struct super_block *get_sb_pseudo(struct file_system_type *, char *,
   struct super_operations *ops, unsigned long);
int __put_super(struct super_block *sb);
int __put_super_and_need_restart(struct super_block *sb);
void unnamed_dev_init(void);
extern int register_filesystem(struct file_system_type *);
extern int unregister_filesystem(struct file_system_type *);
extern struct vfsmount *kern_mount(struct file_system_type *);
extern int may_umount_tree(struct vfsmount *);
extern int may_umount(struct vfsmount *);
extern long do_mount(char *, char *, char *, unsigned long, void *);
extern int vfs_statfs(struct super_block *, struct kstatfs *);
extern int locks_mandatory_locked(struct inode *);
extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
static inline __attribute__((always_inline)) int locks_verify_locked(struct inode *inode)
{
 if ((((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
  return locks_mandatory_locked(inode);
 return 0;
}
extern int rw_verify_area(int, struct file *, loff_t *, size_t);
static inline __attribute__((always_inline)) int locks_verify_truncate(struct inode *inode,
        struct file *filp,
        loff_t size)
{
 if (inode->i_flock && (((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
  return locks_mandatory_area(
   2, inode, filp,
   size < inode->i_size ? size : inode->i_size,
   (size < inode->i_size ? inode->i_size - size
    : size - inode->i_size)
  );
 return 0;
}
static inline __attribute__((always_inline)) int break_lease(struct inode *inode, unsigned int mode)
{
 if (inode->i_flock)
  return __break_lease(inode, mode);
 return 0;
}
extern int do_truncate(struct dentry *, loff_t start);
extern struct file *filp_open(const char *, int, int);
extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
extern int filp_close(struct file *, fl_owner_t id);
extern char * getname(const char *);
extern void __attribute__ ((__section__ (".init.text"))) vfs_caches_init_early(void);
extern void __attribute__ ((__section__ (".init.text"))) vfs_caches_init(unsigned long);
extern int register_blkdev(unsigned int, const char *);
extern int unregister_blkdev(unsigned int, const char *);
extern struct block_device *bdget(dev_t);
extern void bd_set_size(struct block_device *, loff_t size);
extern void bd_forget(struct inode *inode);
extern void bdput(struct block_device *);
extern struct block_device *open_by_devnum(dev_t, unsigned);
extern struct file_operations def_blk_fops;
extern struct address_space_operations def_blk_aops;
extern struct file_operations def_chr_fops;
extern struct file_operations bad_sock_fops;
extern struct file_operations def_fifo_fops;
extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
extern int blkdev_ioctl(struct inode *, struct file *, unsigned, unsigned long);
extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
extern int blkdev_get(struct block_device *, mode_t, unsigned);
extern int blkdev_put(struct block_device *);
extern int bd_claim(struct block_device *, void *);
extern void bd_release(struct block_device *);
extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
extern int register_chrdev_region(dev_t, unsigned, const char *);
extern int register_chrdev(unsigned int, const char *,
      struct file_operations *);
extern int unregister_chrdev(unsigned int, const char *);
extern void unregister_chrdev_region(dev_t, unsigned);
extern int chrdev_open(struct inode *, struct file *);
extern const char *__bdevname(dev_t, char *buffer);
extern const char *bdevname(struct block_device *bdev, char *buffer);
extern struct block_device *lookup_bdev(const char *);
extern struct block_device *open_bdev_excl(const char *, int, void *);
extern void close_bdev_excl(struct block_device *);
extern void init_special_inode(struct inode *, umode_t, dev_t);
extern void make_bad_inode(struct inode *);
extern int is_bad_inode(struct inode *);
extern struct file_operations read_fifo_fops;
extern struct file_operations write_fifo_fops;
extern struct file_operations rdwr_fifo_fops;
extern struct file_operations read_pipe_fops;
extern struct file_operations write_pipe_fops;
extern struct file_operations rdwr_pipe_fops;
extern int fs_may_remount_ro(struct super_block *);
extern int check_disk_change(struct block_device *);
extern int invalidate_inodes(struct super_block *);
extern int __invalidate_device(struct block_device *, int);
extern int invalidate_partition(struct gendisk *, int);
unsigned long invalidate_mapping_pages(struct address_space *mapping,
     unsigned long start, unsigned long end);
unsigned long invalidate_inode_pages(struct address_space *mapping);
static inline __attribute__((always_inline)) void invalidate_remote_inode(struct inode *inode)
{
 if ((((inode->i_mode) & 00170000) == 0100000) || (((inode->i_mode) & 00170000) == 0040000) ||
     (((inode->i_mode) & 00170000) == 0120000))
  invalidate_inode_pages(inode->i_mapping);
}
extern int invalidate_inode_pages2(struct address_space *mapping);
extern int write_inode_now(struct inode *, int);
extern int filemap_fdatawrite(struct address_space *);
extern int filemap_flush(struct address_space *);
extern int filemap_fdatawait(struct address_space *);
extern int filemap_write_and_wait(struct address_space *mapping);
extern void sync_supers(void);
extern void sync_filesystems(int wait);
extern void emergency_sync(void);
extern void emergency_remount(void);
extern int do_remount_sb(struct super_block *sb, int flags,
    void *data, int force);
extern sector_t bmap(struct inode *, sector_t);
extern int setattr_mask(unsigned int);
extern int notify_change(struct dentry *, struct iattr *);
extern int permission(struct inode *, int, struct nameidata *);
extern int generic_permission(struct inode *, int,
  int (*check_acl)(struct inode *, int));
extern int get_write_access(struct inode *);
extern int deny_write_access(struct file *);
static inline __attribute__((always_inline)) void put_write_access(struct inode * inode)
{
 atomic_dec(&inode->i_writecount);
}
static inline __attribute__((always_inline)) void allow_write_access(struct file *file)
{
 if (file)
  atomic_inc(&file->f_dentry->d_inode->i_writecount);
}
extern int do_pipe(int *);
extern int open_namei(const char *, int, int, struct nameidata *);
extern int may_open(struct nameidata *, int, int);
extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
extern struct file * open_exec(const char *);
extern int is_subdir(struct dentry *, struct dentry *);
extern ino_t find_inode_number(struct dentry *, struct qstr *);
static inline __attribute__((always_inline)) void *ERR_PTR(long error)
{
 return (void *) error;
}
static inline __attribute__((always_inline)) long PTR_ERR(const void *ptr)
{
 return (long) ptr;
}
static inline __attribute__((always_inline)) long IS_ERR(const void *ptr)
{
 return __builtin_expect(!!((unsigned long)ptr > (unsigned long)-1000L), 0);
}
extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
extern void inode_init_once(struct inode *);
extern void iput(struct inode *);
extern struct inode * igrab(struct inode *);
extern ino_t iunique(struct super_block *, ino_t);
extern int inode_needs_sync(struct inode *inode);
extern void generic_delete_inode(struct inode *inode);
extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
  int (*test)(struct inode *, void *), void *data);
extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
extern struct inode * iget_locked(struct super_block *, unsigned long);
extern void unlock_new_inode(struct inode *);
static inline __attribute__((always_inline)) struct inode *iget(struct super_block *sb, unsigned long ino)
{
 struct inode *inode = iget_locked(sb, ino);
 if (inode && (inode->i_state & 64)) {
  sb->s_op->read_inode(inode);
  unlock_new_inode(inode);
 }
 return inode;
}
extern void __iget(struct inode * inode);
extern void clear_inode(struct inode *);
extern void destroy_inode(struct inode *);
extern struct inode *new_inode(struct super_block *);
extern int remove_suid(struct dentry *);
extern void remove_dquot_ref(struct super_block *, int, struct list_head *);
extern struct semaphore iprune_sem;
extern void __insert_inode_hash(struct inode *, unsigned long hashval);
extern void remove_inode_hash(struct inode *);
static inline __attribute__((always_inline)) void insert_inode_hash(struct inode *inode) {
 __insert_inode_hash(inode, inode->i_ino);
}
extern struct file * get_empty_filp(void);
extern void file_move(struct file *f, struct list_head *list);
extern void file_kill(struct file *f);
struct bio;
extern void submit_bio(int, struct bio *);
extern int bdev_read_only(struct block_device *);
extern int set_blocksize(struct block_device *, int);
extern int sb_set_blocksize(struct super_block *, int);
extern int sb_min_blocksize(struct super_block *, int);
extern int generic_file_mmap(struct file *, struct vm_area_struct *);
extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
extern int file_send_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
extern ssize_t generic_file_read(struct file *, char *, size_t, loff_t *);
int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
extern ssize_t generic_file_write(struct file *, const char *, size_t, loff_t *);
extern ssize_t do_sync_read(struct file *filp, char *buf, size_t len, loff_t *ppos);
extern ssize_t do_sync_write(struct file *filp, const char *buf, size_t len, loff_t *ppos);
ssize_t generic_file_write_nolock(struct file *file, const struct iovec *iov,
    unsigned long nr_segs, loff_t *ppos);
extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
extern void do_generic_mapping_read(struct address_space *mapping,
        struct file_ra_state *, struct file *,
        loff_t *, read_descriptor_t *, read_actor_t);
extern void
file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
extern ssize_t generic_file_readv(struct file *filp, const struct iovec *iov,
 unsigned long nr_segs, loff_t *ppos);
ssize_t generic_file_writev(struct file *filp, const struct iovec *iov,
   unsigned long nr_segs, loff_t *ppos);
extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
extern loff_t remote_llseek(struct file *file, loff_t offset, int origin);
extern int generic_file_open(struct inode * inode, struct file * filp);
extern int nonseekable_open(struct inode * inode, struct file * filp);
static inline __attribute__((always_inline)) void do_generic_file_read(struct file * filp, loff_t *ppos,
     read_descriptor_t * desc,
     read_actor_t actor)
{
 do_generic_mapping_read(filp->f_mapping,
    &filp->f_ra,
    filp,
    ppos,
    desc,
    actor);
}
extern struct file_operations generic_ro_fops;
extern int vfs_readlink(struct dentry *, char *, int, const char *);
extern int vfs_follow_link(struct nameidata *, const char *);
extern int page_readlink(struct dentry *, char *, int);
extern int page_follow_link_light(struct dentry *, struct nameidata *);
extern void page_put_link(struct dentry *, struct nameidata *);
extern int page_symlink(struct inode *inode, const char *symname, int len);
extern struct inode_operations page_symlink_inode_operations;
extern int generic_readlink(struct dentry *, char *, int);
extern void generic_fillattr(struct inode *, struct kstat *);
extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
void inode_add_bytes(struct inode *inode, loff_t bytes);
void inode_sub_bytes(struct inode *inode, loff_t bytes);
loff_t inode_get_bytes(struct inode *inode);
void inode_set_bytes(struct inode *inode, loff_t bytes);
extern int vfs_readdir(struct file *, filldir_t, void *);
extern int vfs_stat(char *, struct kstat *);
extern int vfs_lstat(char *, struct kstat *);
extern int vfs_fstat(unsigned int, struct kstat *);
extern int vfs_ioctl(struct file *, unsigned int, unsigned int, unsigned long);
extern struct file_system_type *get_fs_type(const char *name);
extern struct super_block *get_super(struct block_device *);
extern struct super_block *user_get_super(dev_t);
extern void drop_super(struct super_block *sb);
extern int dcache_dir_open(struct inode *, struct file *);
extern int dcache_dir_close(struct inode *, struct file *);
extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
extern int dcache_readdir(struct file *, void *, filldir_t);
extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
extern int simple_statfs(struct super_block *, struct kstatfs *);
extern int simple_link(struct dentry *, struct inode *, struct dentry *);
extern int simple_unlink(struct inode *, struct dentry *);
extern int simple_rmdir(struct inode *, struct dentry *);
extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
extern int simple_sync_file(struct file *, struct dentry *, int);
extern int simple_empty(struct dentry *);
extern int simple_readpage(struct file *file, struct page *page);
extern int simple_prepare_write(struct file *file, struct page *page,
   unsigned offset, unsigned to);
extern int simple_commit_write(struct file *file, struct page *page,
    unsigned offset, unsigned to);
extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
extern ssize_t generic_read_dir(struct file *, char *, size_t, loff_t *);
extern struct file_operations simple_dir_operations;
extern struct inode_operations simple_dir_inode_operations;
struct tree_descr { char *name; struct file_operations *ops; int mode; };
struct dentry *d_alloc_name(struct dentry *, const char *);
extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
extern int simple_pin_fs(char *name, struct vfsmount **mount, int *count);
extern void simple_release_fs(struct vfsmount **mount, int *count);
extern ssize_t simple_read_from_buffer(void *, size_t, loff_t *, const void *, size_t);
extern int inode_change_ok(struct inode *, struct iattr *);
extern int __attribute__((warn_unused_result)) inode_setattr(struct inode *, struct iattr *);
extern void inode_update_time(struct inode *inode, int ctime_too);
static inline __attribute__((always_inline)) ino_t parent_ino(struct dentry *dentry)
{
 ino_t res;
 do { do { } while (0); do { (void)(&dentry->d_lock); } while(0); (void)0; } while(0);
 res = dentry->d_parent->d_inode->i_ino;
 do { do { (void)(&dentry->d_lock); } while(0); do { } while (0); (void)0; } while (0);
 return res;
}
extern int unshare_files(void);
struct simple_transaction_argresp {
 ssize_t size;
 char data[0];
};
char *simple_transaction_get(struct file *file, const char *buf,
    size_t size);
ssize_t simple_transaction_read(struct file *file, char *buf,
    size_t size, loff_t *pos);
int simple_transaction_release(struct inode *inode, struct file *file);
static inline __attribute__((always_inline)) void simple_transaction_set(struct file *file, size_t n)
{
 struct simple_transaction_argresp *ar = file->private_data;
 do { if (!__builtin_constant_p(n > ((1UL << 12) - sizeof(struct simple_transaction_argresp))) || (n > ((1UL << 12) - sizeof(struct simple_transaction_argresp)))) { __asm__ __volatile__( "1:	twnei %0,0\n" ".section __bug_table,\"a\"\n\t" "	.long 1b,%1,%2,%3\n" ".previous" : : "r" (n > ((1UL << 12) - sizeof(struct simple_transaction_argresp))), "i" (1646), "i" ("include/linux/fs.h"), "i" ((__func__))); } } while (0);
 __asm__ __volatile__("": : :"memory");
 ar->size = n;
}
static inline __attribute__((always_inline)) char *alloc_secdata(void)
{
 return (char *)1;
}
static inline __attribute__((always_inline)) void free_secdata(void *secdata)
{ }
struct mempolicy;
struct anon_vma;
extern unsigned long max_mapnr;
extern unsigned long num_physpages;
extern void * high_memory;
extern unsigned long vmalloc_earlyreserve;
extern int page_cluster;
extern unsigned long va_to_phys(unsigned long address);
extern pte_t *va_to_pte(unsigned long address);
extern unsigned long ioremap_bot, ioremap_base;
extern unsigned long bad_call_to_PMD_PAGE_SIZE(void);
extern unsigned long empty_zero_page[1024];
static inline __attribute__((always_inline)) int pgd_none(pgd_t pgd) { return 0; }
static inline __attribute__((always_inline)) int pgd_bad(pgd_t pgd) { return 0; }
static inline __attribute__((always_inline)) int pgd_present(pgd_t pgd) { return 1; }
static inline __attribute__((always_inline)) int pte_read(pte_t pte) { return (pte) & 0x004; }
static inline __attribute__((always_inline)) int pte_write(pte_t pte) { return (pte) & 0x400; }
static inline __attribute__((always_inline)) int pte_exec(pte_t pte) { return (pte) & 0x200; }
static inline __attribute__((always_inline)) int pte_dirty(pte_t pte) { return (pte) & 0x080; }
static inline __attribute__((always_inline)) int pte_young(pte_t pte) { return (pte) & 0x100; }
static inline __attribute__((always_inline)) int pte_file(pte_t pte) { return (pte) & 0x004; }
static inline __attribute__((always_inline)) void pte_uncache(pte_t pte) { (pte) |= 0x020; }
static inline __attribute__((always_inline)) void pte_cache(pte_t pte) { (pte) &= ~0x020; }
static inline __attribute__((always_inline)) pte_t pte_rdprotect(pte_t pte) {
 (pte) &= ~0x004; return pte; }
static inline __attribute__((always_inline)) pte_t pte_wrprotect(pte_t pte) {
 (pte) &= ~(0x400 | 0); return pte; }
static inline __attribute__((always_inline)) pte_t pte_exprotect(pte_t pte) {
 (pte) &= ~0x200; return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkclean(pte_t pte) {
 (pte) &= ~(0x080 | 0); return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkold(pte_t pte) {
 (pte) &= ~0x100; return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkread(pte_t pte) {
 (pte) |= 0x004; return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkexec(pte_t pte) {
 (pte) |= 0x004 | 0x200; return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkwrite(pte_t pte) {
 (pte) |= 0x400; return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkdirty(pte_t pte) {
 (pte) |= 0x080; return pte; }
static inline __attribute__((always_inline)) pte_t pte_mkyoung(pte_t pte) {
 (pte) |= 0x100; return pte; }
static inline __attribute__((always_inline)) pte_t pte_modify(pte_t pte, pgprot_t newprot)
{
 (pte) = ((pte) & ((~((1 << 12) - 1)) | 0x100 | 0x080)) | (newprot);
 return pte;
}
static inline __attribute__((always_inline)) unsigned long pte_update(pte_t *p, unsigned long clr,
           unsigned long set)
{
 unsigned long old, tmp;
 __asm__ __volatile__("1:	lwarx	%0,0,%3\n	andc	%1,%0,%4\n	or	%1,%1,%5\n"
"	stwcx.	%1,0,%3\n	bne-	1b"
 : "=&r" (old), "=&r" (tmp), "=m" (*p)
 : "r" ((unsigned long)(p+1) - 4), "r" (clr), "r" (set), "m" (*p)
 : "cc" );
 return old;
}
static inline __attribute__((always_inline)) void set_pte(pte_t *ptep, pte_t pte)
{
 pte_update(ptep, ~0x002, (pte) & ~0x002);
}
extern void flush_hash_one_pte(pte_t *ptep);
static inline __attribute__((always_inline)) int ptep_test_and_clear_young(pte_t *ptep)
{
 unsigned long old;
 old = pte_update(ptep, 0x100, 0);
 if (old & 0x002)
  flush_hash_one_pte(ptep);
 return (old & 0x100) != 0;
}
static inline __attribute__((always_inline)) int ptep_test_and_clear_dirty(pte_t *ptep)
{
 return (pte_update(ptep, (0x080 | 0), 0) & 0x080) != 0;
}
static inline __attribute__((always_inline)) pte_t ptep_get_and_clear(pte_t *ptep)
{
 return (pte_update(ptep, ~0x002, 0));
}
static inline __attribute__((always_inline)) void ptep_set_wrprotect(pte_t *ptep)
{
 pte_update(ptep, (0x400 | 0), 0);
}
static inline __attribute__((always_inline)) void ptep_mkdirty(pte_t *ptep)
{
 pte_update(ptep, 0, 0x080);
}
static inline __attribute__((always_inline)) void __ptep_set_access_flags(pte_t *ptep, pte_t entry, int dirty)
{
 unsigned long bits = (entry) &
  (0x080 | 0x100 | 0x400);
 pte_update(ptep, 0, bits);
}
static inline __attribute__((always_inline)) pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
{
 return (pmd_t *) dir;
}
extern pgd_t swapper_pg_dir[(1 << (32 - (12 + (12 - 2))))];
extern void paging_init(void);
extern int flush_hash_pages(unsigned context, unsigned long va,
       unsigned long pmdval, int count);
extern void add_hash_page(unsigned context, unsigned long va,
     unsigned long pmdval);
extern void cache_clear(__u32 addr, int length);
extern void cache_push(__u32 addr, int length);
extern int mm_end_of_chunk (unsigned long addr, int len);
extern unsigned long iopa(unsigned long addr);
extern unsigned long mm_ptov(unsigned long addr) __attribute__((__const__));
extern unsigned long kernel_map(unsigned long paddr, unsigned long size,
    int nocacheflag, unsigned long *memavailp );
extern void kernel_set_cachemode (unsigned long address, unsigned long size,
                                 unsigned int cmode);
extern int get_pteptr(struct mm_struct *mm, unsigned long addr, pte_t **ptep);
struct vm_area_struct {
 struct mm_struct * vm_mm;
 unsigned long vm_start;
 unsigned long vm_end;
 struct vm_area_struct *vm_next;
 pgprot_t vm_page_prot;
 unsigned long vm_flags;
 struct rb_node vm_rb;
 union {
  struct {
   struct list_head list;
   void *parent;
   struct vm_area_struct *head;
  } vm_set;
  struct raw_prio_tree_node prio_tree_node;
 } shared;
 struct list_head anon_vma_node;
 struct anon_vma *anon_vma;
 struct vm_operations_struct * vm_ops;
 unsigned long vm_pgoff;
 struct file * vm_file;
 void * vm_private_data;
 unsigned long vm_truncate_count;
};
struct vm_list_struct {
 struct vm_list_struct *next;
 struct vm_area_struct *vma;
};
extern pgprot_t protection_map[16];
struct vm_operations_struct {
 void (*open)(struct vm_area_struct * area);
 void (*close)(struct vm_area_struct * area);
 struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int *type);
 int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);
};
struct mmu_gather;
struct inode;
typedef unsigned long page_flags_t;
struct page {
 page_flags_t flags;
 atomic_t _count;
 atomic_t _mapcount;
 unsigned long private;
 struct address_space *mapping;
 unsigned long index;
 struct list_head lru;
};
struct page_state {
 unsigned long nr_dirty;
 unsigned long nr_writeback;
 unsigned long nr_unstable;
 unsigned long nr_page_table_pages;
 unsigned long nr_mapped;
 unsigned long nr_slab;
 unsigned long pgpgin;
 unsigned long pgpgout;
 unsigned long pswpin;
 unsigned long pswpout;
 unsigned long pgalloc_high;
 unsigned long pgalloc_normal;
 unsigned long pgalloc_dma;
 unsigned long pgfree;
 unsigned long pgactivate;
 unsigned long pgdeactivate;
 unsigned long pgfault;
 unsigned long pgmajfault;
 unsigned long pgrefill_high;
 unsigned long pgrefill_normal;
 unsigned long pgrefill_dma;
 unsigned long pgsteal_high;
 unsigned long pgsteal_normal;
 unsigned long pgsteal_dma;
 unsigned long pgscan_kswapd_high;
 unsigned long pgscan_kswapd_normal;
 unsigned long pgscan_kswapd_dma;
 unsigned long pgscan_direct_high;
 unsigned long pgscan_direct_normal;
 unsigned long pgscan_direct_dma;
 unsigned long pginodesteal;
 unsigned long slabs_scanned;
 unsigned long kswapd_steal;
 unsigned long kswapd_inodesteal;
 unsigned long pageoutrun;
 unsigned long allocstall;
 unsigned long pgrotated;
};
extern void get_page_state(struct page_state *ret);
extern void get_full_page_state(struct page_state *ret);
extern unsigned long __read_page_state(unsigned offset);
extern void __mod_page_state(unsigned offset, unsigned long delta);
struct page;
int test_clear_page_dirty(struct page *page);
int __clear_page_dirty(struct page *page);
int test_clear_page_writeback(struct page *page);
int test_set_page_writeback(struct page *page);
static inline __attribute__((always_inline)) void clear_page_dirty(struct page *page)
{
 test_clear_page_dirty(page);
}
static inline __attribute__((always_inline)) void set_page_writeback(struct page *page)
{
 test_set_page_writeback(page);
}
extern void __page_cache_release(struct page *);
static inline __attribute__((always_inline)) void get_page(struct page *page)
{
 atomic_inc(&page->_count);
}
static inline __attribute__((always_inline)) void put_page(struct page *page)
{
 if (!test_bit(11, &(page)->flags) && ({ do { if (!__builtin_constant_p((((&(page)->_count)->counter) + 1) == 0) || ((((&(page)->_count)->counter) + 1) == 0)) { __asm__ __volatile__( "1:	twnei %0,0\n" ".section __bug_table,\"a\"\n\t" "	.long 1b,%1,%2,%3\n" ".previous" : : "r" ((((&(page)->_count)->counter) + 1) == 0), "i" (343), "i" ("include/linux/mm.h"), "i" ((__func__))); } } while (0); (atomic_add_return((-1), (&(page)->_count)) < 0); }))
  __page_cache_release(page);
}
static inline __attribute__((always_inline)) unsigned long page_zonenum(struct page *page)
{
 return (page->flags >> (sizeof(page_flags_t)*8 - 1 - 2)) & (~(~0UL << 2));
}
static inline __attribute__((always_inline)) unsigned long page_to_nid(struct page *page)
{
 return (page->flags >> ((sizeof(page_flags_t)*8 - 1 - 2) + 2));
}
struct zone;
extern struct zone *zone_table[];
static inline __attribute__((always_inline)) struct zone *page_zone(struct page *page)
{
 return zone_table[page->flags >> (sizeof(page_flags_t)*8 - 1 - 2)];
}
static inline __attribute__((always_inline)) void set_page_zone(struct page *page, unsigned long nodezone_num)
{
 page->flags &= ~(~0UL << (sizeof(page_flags_t)*8 - 1 - 2));
 page->flags |= nodezone_num << (sizeof(page_flags_t)*8 - 1 - 2);
}
extern struct page *mem_map;
static inline __attribute__((always_inline)) void *lowmem_page_address(struct page *page)
{
 return ((void *)((((unsigned long)(((unsigned long)((page) - mem_map) + 0) << 12))+0xc0000000)));
}
extern struct address_space swapper_space;
static inline __attribute__((always_inline)) struct address_space *page_mapping(struct page *page)
{
 struct address_space *mapping = page->mapping;
 if (__builtin_expect(!!(0), 0))
  mapping = &swapper_space;
 else if (__builtin_expect(!!((unsigned long)mapping & 1), 0))
  mapping = ((void *)0);
 return mapping;
}
static inline __attribute__((always_inline)) int PageAnon(struct page *page)
{
 return ((unsigned long)page->mapping & 1) != 0;
}
static inline __attribute__((always_inline)) unsigned long page_index(struct page *page)
{
 if (__builtin_expect(!!(0), 0))
  return page->private;
 return page->index;
}
static inline __attribute__((always_inline)) void reset_page_mapcount(struct page *page)
{
 (((&(page)->_mapcount)->counter) = (-1));
}
static inline __attribute__((always_inline)) int page_mapcount(struct page *page)
{
 return ((&(page)->_mapcount)->counter) + 1;
}
static inline __attribute__((always_inline)) int page_mapped(struct page *page)
{
 return ((&(page)->_mapcount)->counter) >= 0;
}
extern void show_free_areas(void);
struct page *shmem_nopage(struct vm_area_struct *vma,
   unsigned long address, int *type);
int shmem_set_policy(struct vm_area_struct *vma, struct mempolicy *new);
struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
     unsigned long addr);
int shmem_lock(struct file *file, int lock, struct user_struct *user);
struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
int shmem_zero_setup(struct vm_area_struct *);
static inline __attribute__((always_inline)) int can_do_mlock(void)
{
 if (capable(14))
  return 1;
 if (current->signal->rlim[8].rlim_cur != 0)
  return 1;
 return 0;
}
extern int user_shm_lock(size_t, struct user_struct *);
extern void user_shm_unlock(size_t, struct user_struct *);
struct zap_details {
 struct vm_area_struct *nonlinear_vma;
 struct address_space *check_mapping;
 unsigned long first_index;
 unsigned long last_index;
 spinlock_t *i_mmap_lock;
 unsigned long break_addr;
 unsigned long truncate_count;
};
void zap_page_range(struct vm_area_struct *vma, unsigned long address,
  unsigned long size, struct zap_details *);
int unmap_vmas(struct mmu_gather **tlbp, struct mm_struct *mm,
  struct vm_area_struct *start_vma, unsigned long start_addr,
  unsigned long end_addr, unsigned long *nr_accounted,
  struct zap_details *);
void clear_page_range(struct mmu_gather *tlb, unsigned long addr, unsigned long end);
int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
   struct vm_area_struct *vma);
int zeromap_page_range(struct vm_area_struct *vma, unsigned long from,
   unsigned long size, pgprot_t prot);
void unmap_mapping_range(struct address_space *mapping,
  loff_t const holebegin, loff_t const holelen, int even_cows);
static inline __attribute__((always_inline)) void unmap_shared_mapping_range(struct address_space *mapping,
  loff_t const holebegin, loff_t const holelen)
{
 unmap_mapping_range(mapping, holebegin, holelen, 0);
}
extern int vmtruncate(struct inode * inode, loff_t offset);
extern pgd_t *__pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
extern pmd_t *__pmd_alloc(struct mm_struct *mm, pgd_t *pud, unsigned long address);
extern pte_t *pte_alloc_kernel(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
extern pte_t *pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
extern int handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
extern int make_pages_present(unsigned long addr, unsigned long end);
extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
  int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
int __set_page_dirty_buffers(struct page *page);
int __set_page_dirty_nobuffers(struct page *page);
int redirty_page_for_writepage(struct writeback_control *wbc,
    struct page *page);
int set_page_dirty(struct page *page);
int set_page_dirty_lock(struct page *page);
int clear_page_dirty_for_io(struct page *page);
extern unsigned long do_mremap(unsigned long addr,
          unsigned long old_len, unsigned long new_len,
          unsigned long flags, unsigned long new_addr);
typedef int (*shrinker_t)(int nr_to_scan, unsigned int gfp_mask);
struct shrinker;
extern struct shrinker *set_shrinker(int, shrinker_t);
extern void remove_shrinker(struct shrinker *shrinker);
extern void free_area_init(unsigned long * zones_size);
extern void free_area_init_node(int nid, pg_data_t *pgdat,
 unsigned long * zones_size, unsigned long zone_start_pfn,
 unsigned long *zholes_size);
extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long);
extern void mem_init(void);
extern void show_mem(void);
extern void si_meminfo(struct sysinfo * val);
extern void si_meminfo_node(struct sysinfo *val, int nid);
void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
void vma_prio_tree_remove(struct vm_area_struct *, struct prio_tree_root *);
struct vm_area_struct *vma_prio_tree_next(struct vm_area_struct *vma,
 struct prio_tree_iter *iter);
static inline __attribute__((always_inline)) void vma_nonlinear_insert(struct vm_area_struct *vma,
     struct list_head *list)
{
 vma->shared.vm_set.parent = ((void *)0);
 list_add_tail(&vma->shared.vm_set.list, list);
}
extern int __vm_enough_memory(long pages, int cap_sys_admin);
extern void vma_adjust(struct vm_area_struct *vma, unsigned long start,
 unsigned long end, unsigned long pgoff, struct vm_area_struct *insert);
extern struct vm_area_struct *vma_merge(struct mm_struct *,
 struct vm_area_struct *prev, unsigned long addr, unsigned long end,
 unsigned long vm_flags, struct anon_vma *, struct file *, unsigned long,
 struct mempolicy *);
extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
extern int split_vma(struct mm_struct *,
 struct vm_area_struct *, unsigned long addr, int new_below);
extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
 struct rb_node **, struct rb_node *);
extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
 unsigned long addr, unsigned long len, unsigned long pgoff);
extern void exit_mmap(struct mm_struct *);
extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
 unsigned long len, unsigned long prot,
 unsigned long flag, unsigned long pgoff);
static inline __attribute__((always_inline)) unsigned long do_mmap(struct file *file, unsigned long addr,
 unsigned long len, unsigned long prot,
 unsigned long flag, unsigned long offset)
{
 unsigned long ret = -22;
 if ((offset + (((len)+(1UL << 12)-1)&(~((1 << 12) - 1)))) < offset)
  goto out;
 if (!(offset & ~(~((1 << 12) - 1))))
  ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> 12);
out:
 return ret;
}
extern int do_munmap(struct mm_struct *, unsigned long, size_t);
extern unsigned long do_brk(unsigned long, unsigned long);
extern unsigned long page_unuse(struct page *);
extern void truncate_inode_pages(struct address_space *, loff_t);
extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int *);
extern int filemap_populate(struct vm_area_struct *, unsigned long,
  unsigned long, pgprot_t, unsigned long, int);
int write_one_page(struct page *page, int wait);
int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
   unsigned long offset, unsigned long nr_to_read);
int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
   unsigned long offset, unsigned long nr_to_read);
unsigned long page_cache_readahead(struct address_space *mapping,
     struct file_ra_state *ra,
     struct file *filp,
     unsigned long offset,
     unsigned long size);
void handle_ra_miss(struct address_space *mapping,
      struct file_ra_state *ra, unsigned long offset);
unsigned long max_sane_readahead(unsigned long nr);
extern int expand_stack(struct vm_area_struct * vma, unsigned long address);
extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
          struct vm_area_struct **pprev);
static inline __attribute__((always_inline)) struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
{
 struct vm_area_struct * vma = find_vma(mm,start_addr);
 if (vma && end_addr <= vma->vm_start)
  vma = ((void *)0);
 return vma;
}
static inline __attribute__((always_inline)) unsigned long vma_pages(struct vm_area_struct *vma)
{
 return (vma->vm_end - vma->vm_start) >> 12;
}
extern struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr);
extern struct page * vmalloc_to_page(void *addr);
extern unsigned long vmalloc_to_pfn(void *addr);
extern struct page * follow_page(struct mm_struct *mm, unsigned long address,
  int write);
extern int check_user_page_readable(struct mm_struct *mm, unsigned long address);
int remap_pfn_range(struct vm_area_struct *, unsigned long,
  unsigned long, unsigned long, pgprot_t);
static inline __attribute__((always_inline)) void __vm_stat_account(struct mm_struct *mm,
   unsigned long flags, struct file *file, long pages)
{
}
static inline __attribute__((always_inline)) void vm_stat_account(struct vm_area_struct *vma)
{
 __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
       vma_pages(vma));
}
static inline __attribute__((always_inline)) void vm_stat_unaccount(struct vm_area_struct *vma)
{
 __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
       -vma_pages(vma));
}
extern void update_mem_hiwater(void);
static inline __attribute__((always_inline)) void
kernel_map_pages(struct page *page, int numpages, int enable)
{
}
extern struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
int in_gate_area_no_task(unsigned long addr);
extern inline __attribute__((always_inline)) int verify_area(int type, const void * addr, unsigned long size)
{
 return ((void)0,(((unsigned long)(addr)) <= current->thread.fs.seg && (((size)) == 0 || ((size)) - 1 <= current->thread.fs.seg - ((unsigned long)(addr))))) ? 0 : -14;
}
struct exception_table_entry
{
 unsigned long insn, fixup;
};
extern long __put_user_bad(void);
extern long __get_user_bad(void);
extern int __copy_tofrom_user(void *to, const void *from,
         unsigned long size);
extern inline __attribute__((always_inline)) unsigned long
copy_from_user(void *to, const void *from, unsigned long n)
{
 unsigned long over;
 if (((void)0,(((unsigned long)(from)) <= current->thread.fs.seg && (((n)) == 0 || ((n)) - 1 <= current->thread.fs.seg - ((unsigned long)(from))))))
  return __copy_tofrom_user(( void *)to, from, n);
 if ((unsigned long)from < (0x80000000)) {
  over = (unsigned long)from + n - (0x80000000);
  return __copy_tofrom_user(( void *)to, from, n - over) + over;
 }
 return n;
}
extern inline __attribute__((always_inline)) unsigned long
copy_to_user(void *to, const void *from, unsigned long n)
{
 unsigned long over;
 if (((void)0,(((unsigned long)(to)) <= current->thread.fs.seg && (((n)) == 0 || ((n)) - 1 <= current->thread.fs.seg - ((unsigned long)(to))))))
  return __copy_tofrom_user(to, ( void *) from, n);
 if ((unsigned long)to < (0x80000000)) {
  over = (unsigned long)to + n - (0x80000000);
  return __copy_tofrom_user(to, ( void *) from, n - over) + over;
 }
 return n;
}
static inline __attribute__((always_inline)) unsigned long __copy_from_user(void *to, const void *from, unsigned long size)
{
 return __copy_tofrom_user(( void *)to, from, size);
}
static inline __attribute__((always_inline)) unsigned long __copy_to_user(void *to, const void *from, unsigned long size)
{
 return __copy_tofrom_user(to, ( void *)from, size);
}
extern unsigned long __clear_user(void *addr, unsigned long size);
extern inline __attribute__((always_inline)) unsigned long
clear_user(void *addr, unsigned long size)
{
 if (((void)0,(((unsigned long)(addr)) <= current->thread.fs.seg && (((size)) == 0 || ((size)) - 1 <= current->thread.fs.seg - ((unsigned long)(addr))))))
  return __clear_user(addr, size);
 if ((unsigned long)addr < (0x80000000)) {
  unsigned long over = (unsigned long)addr + size - (0x80000000);
  return __clear_user(addr, size - over) + over;
 }
 return size;
}
extern int __strncpy_from_user(char *dst, const char *src, long count);
extern inline __attribute__((always_inline)) long
strncpy_from_user(char *dst, const char *src, long count)
{
 if (((void)0,(((unsigned long)(src)) <= current->thread.fs.seg && (((1)) == 0 || ((1)) - 1 <= current->thread.fs.seg - ((unsigned long)(src))))))
  return __strncpy_from_user(dst, src, count);
 return -14;
}
extern int __strnlen_user(const char *str, long len, unsigned long top);
extern __inline__ __attribute__((always_inline)) int strnlen_user(const char *str, long len)
{
 unsigned long top = current->thread.fs.seg;
 if ((unsigned long)str > top)
  return 0;
 return __strnlen_user(str, len, top);
}
struct poll_table_struct;
typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
typedef struct poll_table_struct {
 poll_queue_proc qproc;
} poll_table;
static inline __attribute__((always_inline)) void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
 if (p && wait_address)
  p->qproc(filp, wait_address, p);
}
static inline __attribute__((always_inline)) void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
{
 pt->qproc = qproc;
}
struct poll_wqueues {
 poll_table pt;
 struct poll_table_page * table;
 int error;
};
extern void poll_initwait(struct poll_wqueues *pwq);
extern void poll_freewait(struct poll_wqueues *pwq);
typedef struct {
 unsigned long *in, *out, *ex;
 unsigned long *res_in, *res_out, *res_ex;
} fd_set_bits;
static inline __attribute__((always_inline))
int get_fd_set(unsigned long nr, void *ufdset, unsigned long *fdset)
{
 nr = ((((nr)+(8*sizeof(long))-1)/(8*sizeof(long)))*sizeof(long));
 if (ufdset) {
  int error;
  error = verify_area(1, ufdset, nr);
  if (!error && __copy_from_user(fdset, ufdset, nr))
   error = -14;
  return error;
 }
 memset(fdset, 0, nr);
 return 0;
}
static inline __attribute__((always_inline)) unsigned long __attribute__((warn_unused_result))
set_fd_set(unsigned long nr, void *ufdset, unsigned long *fdset)
{
 if (ufdset)
  return __copy_to_user(ufdset, fdset, ((((nr)+(8*sizeof(long))-1)/(8*sizeof(long)))*sizeof(long)));
 return 0;
}
static inline __attribute__((always_inline))
void zero_fd_set(unsigned long nr, unsigned long *fdset)
{
 memset(fdset, 0, ((((nr)+(8*sizeof(long))-1)/(8*sizeof(long)))*sizeof(long)));
}
extern int do_select(int n, fd_set_bits *fds, long *timeout);
struct resource {
 const char *name;
 unsigned long start, end;
 unsigned long flags;
 struct resource *parent, *sibling, *child;
};
struct resource_list {
 struct resource_list *next;
 struct resource *res;
 struct pci_dev *dev;
};
extern struct resource ioport_resource;
extern struct resource iomem_resource;
extern int get_resource_list(struct resource *, char *buf, int size);
extern int request_resource(struct resource *root, struct resource *new);
extern struct resource * ____request_resource(struct resource *root, struct resource *new);
extern int release_resource(struct resource *new);
extern int insert_resource(struct resource *parent, struct resource *new);
extern int allocate_resource(struct resource *root, struct resource *new,
        unsigned long size,
        unsigned long min, unsigned long max,
        unsigned long align,
        void (*alignf)(void *, struct resource *,
         unsigned long, unsigned long),
        void *alignf_data);
int adjust_resource(struct resource *res, unsigned long start,
      unsigned long size);
extern struct resource * __request_region(struct resource *, unsigned long start, unsigned long n, const char *name);
extern int __check_region(struct resource *, unsigned long, unsigned long);
extern void __release_region(struct resource *, unsigned long, unsigned long);
static inline __attribute__((always_inline)) int __attribute__((deprecated)) check_region(unsigned long s, unsigned long n)
{
 return __check_region(&ioport_resource, s, n);
}
typedef int pm_request_t;
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,
};
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;
};
static inline __attribute__((always_inline)) struct pm_dev *pm_register(pm_dev_t type,
      unsigned long id,
      pm_callback callback)
{
 return ((void *)0);
}
static inline __attribute__((always_inline)) void pm_unregister(struct pm_dev *dev) {}
static inline __attribute__((always_inline)) void pm_unregister_all(pm_callback callback) {}
static inline __attribute__((always_inline)) int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data)
{
 return 0;
}
static inline __attribute__((always_inline)) int pm_send_all(pm_request_t rqst, void *data)
{
 return 0;
}
extern void (*pm_idle)(void);
extern void (*pm_power_off)(void);
typedef int suspend_state_t;
typedef int suspend_disk_method_t;
struct pm_ops {
 suspend_disk_method_t pm_disk_mode;
 int (*prepare)(suspend_state_t state);
 int (*enter)(suspend_state_t state);
 int (*finish)(suspend_state_t state);
};
extern void pm_set_ops(struct pm_ops *);
extern int pm_suspend(suspend_state_t state);
struct device;
typedef u32 pm_message_t;
struct dev_pm_info {
 pm_message_t power_state;
};
extern void device_pm_set_parent(struct device * dev, struct device * parent);
extern int device_suspend(pm_message_t state);
extern int device_power_down(pm_message_t state);
extern void device_power_up(void);
extern void device_resume(void);
enum {
 SUSPEND_NOTIFY,
 SUSPEND_SAVE_STATE,
 SUSPEND_DISABLE,
 SUSPEND_POWER_DOWN,
};
enum {
 RESUME_POWER_ON,
 RESUME_RESTORE_STATE,
 RESUME_ENABLE,
};
struct device;
struct device_driver;
struct class;
struct class_device;
struct class_simple;
struct bus_type {
 char * name;
 struct subsystem subsys;
 struct kset drivers;
 struct kset devices;
 struct bus_attribute * bus_attrs;
 struct device_attribute * dev_attrs;
 struct driver_attribute * drv_attrs;
 int (*match)(struct device * dev, struct device_driver * drv);
 int (*hotplug) (struct device *dev, char **envp,
        int num_envp, char *buffer, int buffer_size);
 int (*suspend)(struct device * dev, pm_message_t state);
 int (*resume)(struct device * dev);
};
extern int bus_register(struct bus_type * bus);
extern void bus_unregister(struct bus_type * bus);
extern int bus_rescan_devices(struct bus_type * bus);
extern struct bus_type * get_bus(struct bus_type * bus);
extern void put_bus(struct bus_type * bus);
extern struct bus_type * find_bus(char * name);
int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
       int (*fn)(struct device *, void *));
int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
       void * data, int (*fn)(struct device_driver *, void *));
struct bus_attribute {
 struct attribute attr;
 ssize_t (*show)(struct bus_type *, char * buf);
 ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
};
extern int bus_create_file(struct bus_type *, struct bus_attribute *);
extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
struct device_driver {
 char * name;
 struct bus_type * bus;
 struct semaphore unload_sem;
 struct kobject kobj;
 struct list_head devices;
 struct module * owner;
 int (*probe) (struct device * dev);
 int (*remove) (struct device * dev);
 void (*shutdown) (struct device * dev);
 int (*suspend) (struct device * dev, u32 state, u32 level);
 int (*resume) (struct device * dev, u32 level);
};
extern int driver_register(struct device_driver * drv);
extern void driver_unregister(struct device_driver * drv);
extern struct device_driver * get_driver(struct device_driver * drv);
extern void put_driver(struct device_driver * drv);
extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
struct driver_attribute {
 struct attribute attr;
 ssize_t (*show)(struct device_driver *, char * buf);
 ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
};
extern int driver_create_file(struct device_driver *, struct driver_attribute *);
extern void driver_remove_file(struct device_driver *, struct driver_attribute *);
struct class {
 char * name;
 struct subsystem subsys;
 struct list_head children;
 struct list_head interfaces;
 struct class_attribute * class_attrs;
 struct class_device_attribute * class_dev_attrs;
 int (*hotplug)(struct class_device *dev, char **envp,
      int num_envp, char *buffer, int buffer_size);
 void (*release)(struct class_device *dev);
 void (*class_release)(struct class *class);
};
extern int class_register(struct class *);
extern void class_unregister(struct class *);
extern struct class * class_get(struct class *);
extern void class_put(struct class *);
struct class_attribute {
 struct attribute attr;
 ssize_t (*show)(struct class *, char * buf);
 ssize_t (*store)(struct class *, const char * buf, size_t count);
};
extern int class_create_file(struct class *, const struct class_attribute *);
extern void class_remove_file(struct class *, const struct class_attribute *);
struct class_device {
 struct list_head node;
 struct kobject kobj;
 struct class * class;
 struct device * dev;
 void * class_data;
 char class_id[20];
};
static inline __attribute__((always_inline)) void *
class_get_devdata (struct class_device *dev)
{
 return dev->class_data;
}
static inline __attribute__((always_inline)) void
class_set_devdata (struct class_device *dev, void *data)
{
 dev->class_data = data;
}
extern int class_device_register(struct class_device *);
extern void class_device_unregister(struct class_device *);
extern void class_device_initialize(struct class_device *);
extern int class_device_add(struct class_device *);
extern void class_device_del(struct class_device *);
extern int class_device_rename(struct class_device *, char *);
extern struct class_device * class_device_get(struct class_device *);
extern void class_device_put(struct class_device *);
struct class_device_attribute {
 struct attribute attr;
 ssize_t (*show)(struct class_device *, char * buf);
 ssize_t (*store)(struct class_device *, const char * buf, size_t count);
};
extern int class_device_create_file(struct class_device *,
        const struct class_device_attribute *);
extern void class_device_remove_file(struct class_device *,
         const struct class_device_attribute *);
extern int class_device_create_bin_file(struct class_device *,
     struct bin_attribute *);
extern void class_device_remove_bin_file(struct class_device *,
      struct bin_attribute *);
struct class_interface {
 struct list_head node;
 struct class *class;
 int (*add) (struct class_device *);
 void (*remove) (struct class_device *);
};
extern int class_interface_register(struct class_interface *);
extern void class_interface_unregister(struct class_interface *);
extern struct class_simple *class_simple_create(struct module *owner, char *name);
extern void class_simple_destroy(struct class_simple *cs);
extern struct class_device *class_simple_device_add(struct class_simple *cs, dev_t dev, struct device *device, const char *fmt, ...)
 __attribute__((format(printf,4,5)));
extern int class_simple_set_hotplug(struct class_simple *,
 int (*hotplug)(struct class_device *dev, char **envp, int num_envp, char *buffer, int buffer_size));
extern void class_simple_device_remove(dev_t dev);
struct device {
 struct list_head node;
 struct list_head bus_list;
 struct list_head driver_list;
 struct list_head children;
 struct device * parent;
 struct kobject kobj;
 char bus_id[20];
 struct bus_type * bus;
 struct device_driver *driver;
 void *driver_data;
 void *platform_data;
 struct dev_pm_info power;
 u32 detach_state;
 u64 *dma_mask;
 u64 coherent_dma_mask;
 struct list_head dma_pools;
 struct dma_coherent_mem *dma_mem;
 void (*release)(struct device * dev);
};
static inline __attribute__((always_inline)) struct device *
list_to_dev(struct list_head *node)
{
 return ({ const typeof( ((struct device *)0)->node ) *__mptr = (node); (struct device *)( (char *)__mptr - ((size_t) &((struct device *)0)->node) );});
}
static inline __attribute__((always_inline)) void *
dev_get_drvdata (struct device *dev)
{
 return dev->driver_data;
}
static inline __attribute__((always_inline)) void
dev_set_drvdata (struct device *dev, void *data)
{
 dev->driver_data = data;
}
extern int device_register(struct device * dev);
extern void device_unregister(struct device * dev);
extern void device_initialize(struct device * dev);
extern int device_add(struct device * dev);
extern void device_del(struct device * dev);
extern int device_for_each_child(struct device *, void *,
       int (*fn)(struct device *, void *));
extern int driver_probe_device(struct device_driver * drv, struct device * dev);
extern void device_bind_driver(struct device * dev);
extern void device_release_driver(struct device * dev);
extern int device_attach(struct device * dev);
extern void driver_attach(struct device_driver * drv);
struct device_attribute {
 struct attribute attr;
 ssize_t (*show)(struct device * dev, char * buf);
 ssize_t (*store)(struct device * dev, const char * buf, size_t count);
};
extern int device_create_file(struct device *device, struct device_attribute * entry);
extern void device_remove_file(struct device * dev, struct device_attribute * attr);
extern int (*platform_notify)(struct device * dev);
extern int (*platform_notify_remove)(struct device * dev);
extern struct device * get_device(struct device * dev);
extern void put_device(struct device * dev);
extern struct device *device_find(const char *name, struct bus_type *bus);
struct platform_device {
 char * name;
 u32 id;
 struct device dev;
 u32 num_resources;
 struct resource * resource;
};
extern int platform_device_register(struct platform_device *);
extern void platform_device_unregister(struct platform_device *);
extern struct bus_type platform_bus_type;
extern struct device platform_bus;
extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
extern int platform_get_irq(struct platform_device *, unsigned int);
extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);
extern int platform_get_irq_byname(struct platform_device *, char *);
extern int platform_add_devices(struct platform_device **, int);
extern struct platform_device *platform_device_register_simple(char *, unsigned int, struct resource *, unsigned int);
extern void device_shutdown(void);
extern int firmware_register(struct subsystem *);
extern void firmware_unregister(struct subsystem *);
enum {
 DOS_EXTENDED_PARTITION = 5,
 LINUX_EXTENDED_PARTITION = 0x85,
 WIN98_EXTENDED_PARTITION = 0x0f,
 LINUX_SWAP_PARTITION = 0x82,
 LINUX_RAID_PARTITION = 0xfd,
 SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
 NEW_SOLARIS_X86_PARTITION = 0xbf,
 DM6_AUX1PARTITION = 0x51,
 DM6_AUX3PARTITION = 0x53,
 DM6_PARTITION = 0x54,
 EZD_PARTITION = 0x55,
 FREEBSD_PARTITION = 0xa5,
 OPENBSD_PARTITION = 0xa6,
 NETBSD_PARTITION = 0xa9,
 BSDI_PARTITION = 0xb7,
 MINIX_PARTITION = 0x81,
 UNIXWARE_PARTITION = 0x63,
};
struct partition {
 unsigned char boot_ind;
 unsigned char head;
 unsigned char sector;
 unsigned char cyl;
 unsigned char sys_ind;
 unsigned char end_head;
 unsigned char end_sector;
 unsigned char end_cyl;
 __le32 start_sect;
 __le32 nr_sects;
} __attribute__((packed));
struct hd_struct {
 sector_t start_sect;
 sector_t nr_sects;
 struct kobject kobj;
 unsigned reads, read_sectors, writes, write_sectors;
 int policy, partno;
};
struct disk_stats {
 unsigned read_sectors, write_sectors;
 unsigned reads, writes;
 unsigned read_merges, write_merges;
 unsigned read_ticks, write_ticks;
 unsigned io_ticks;
 unsigned time_in_queue;
};
struct gendisk {
 int major;
 int first_minor;
 int minors;
 char disk_name[32];
 struct hd_struct **part;
 struct block_device_operations *fops;
 struct request_queue *queue;
 void *private_data;
 sector_t capacity;
 int flags;
 char devfs_name[64];
 int number;
 struct device *driverfs_dev;
 struct kobject kobj;
 struct timer_rand_state *random;
 int policy;
 atomic_t sync_io;
 unsigned long stamp, stamp_idle;
 int in_flight;
 struct disk_stats dkstats;
};
struct disk_attribute {
 struct attribute attr;
 ssize_t (*show)(struct gendisk *, char *);
};
static inline __attribute__((always_inline)) void disk_stat_set_all(struct gendisk *gendiskp, int value) {
 memset(&gendiskp->dkstats, value, sizeof (struct disk_stats));
}
static inline __attribute__((always_inline)) int init_disk_stats(struct gendisk *disk)
{
 return 1;
}
static inline __attribute__((always_inline)) void free_disk_stats(struct gendisk *disk)
{
}
extern void disk_round_stats(struct gendisk *disk);
extern int get_blkdev_list(char *);
extern void add_disk(struct gendisk *disk);
extern void del_gendisk(struct gendisk *gp);
extern void unlink_gendisk(struct gendisk *gp);
extern struct gendisk *get_gendisk(dev_t dev, int *part);
extern void set_device_ro(struct block_device *bdev, int flag);
extern void set_disk_ro(struct gendisk *disk, int flag);
extern void add_disk_randomness(struct gendisk *disk);
extern void rand_initialize_disk(struct gendisk *disk);
static inline __attribute__((always_inline)) sector_t get_start_sect(struct block_device *bdev)
{
 return bdev->bd_contains == bdev ? 0 : bdev->bd_part->start_sect;
}
static inline __attribute__((always_inline)) sector_t get_capacity(struct gendisk *disk)
{
 return disk->capacity;
}
static inline __attribute__((always_inline)) void set_capacity(struct gendisk *disk, sector_t size)
{
 disk->capacity = size;
}
char *disk_name (struct gendisk *hd, int part, char *buf);
extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
extern void add_partition(struct gendisk *, int, sector_t, sector_t);
extern void delete_partition(struct gendisk *, int);
extern struct gendisk *alloc_disk(int minors);
extern struct kobject *get_disk(struct gendisk *disk);
extern void put_disk(struct gendisk *disk);
extern void blk_register_region(dev_t dev, unsigned long range,
   struct module *module,
   struct kobject *(*probe)(dev_t, int *, void *),
   int (*lock)(dev_t, void *),
   void *data);
extern void blk_unregister_region(dev_t dev, unsigned long range);
static inline __attribute__((always_inline)) struct block_device *bdget_disk(struct gendisk *disk, int index)
{
 return bdget((((disk->major) << 20) | (disk->first_minor)) + index);
}
typedef int irqreturn_t;
struct irqaction {
 irqreturn_t (*handler)(int, void *, struct pt_regs *);
 unsigned long flags;
 cpumask_t mask;
 const char *name;
 void *dev_id;
 struct irqaction *next;
 int irq;
 struct proc_dir_entry *dir;
};
extern irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs);
extern int request_irq(unsigned int,
         irqreturn_t (*handler)(int, void *, struct pt_regs *),
         unsigned long, const char *, void *);
extern void free_irq(unsigned int, void *);
extern void disable_irq_nosync(unsigned int irq);
extern void disable_irq(unsigned int irq);
extern void enable_irq(unsigned int irq);
static inline __attribute__((always_inline)) void __attribute__((deprecated)) cli(void)
{
 local_irq_disable();
}
static inline __attribute__((always_inline)) void __attribute__((deprecated)) sti(void)
{
 local_irq_enable();
}
static inline __attribute__((always_inline)) void __attribute__((deprecated)) save_flags(unsigned long *x)
{
 ((*x) = ({unsigned int rval; asm volatile("mfmsr %0" : "=r" (rval)); rval;}));
}
static inline __attribute__((always_inline)) void __attribute__((deprecated)) restore_flags(unsigned long x)
{
 asm volatile("mtmsr %0" : : "r" (x));
}
static inline __attribute__((always_inline)) void __attribute__((deprecated)) save_and_cli(unsigned long *x)
{
 local_irq_save_ptr(&*x);
}
extern void local_bh_enable(void);
enum
{
 HI_SOFTIRQ=0,
 TIMER_SOFTIRQ,
 NET_TX_SOFTIRQ,
 NET_RX_SOFTIRQ,
 SCSI_SOFTIRQ,
 TASKLET_SOFTIRQ
};
struct softirq_action
{
 void (*action)(struct softirq_action *);
 void *data;
};
 void do_softirq(void);
extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data);
extern void softirq_init(void);
extern void raise_softirq_irqoff(unsigned int nr);
extern void raise_softirq(unsigned int nr);
struct tasklet_struct
{
 struct tasklet_struct *next;
 unsigned long state;
 atomic_t count;
 void (*func)(unsigned long);
 unsigned long data;
};
enum
{
 TASKLET_STATE_SCHED,
 TASKLET_STATE_RUN
};
extern void __tasklet_schedule(struct tasklet_struct *t);
static inline __attribute__((always_inline)) void tasklet_schedule(struct tasklet_struct *t)
{
 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
  __tasklet_schedule(t);
}
extern void __tasklet_hi_schedule(struct tasklet_struct *t);
static inline __attribute__((always_inline)) void tasklet_hi_schedule(struct tasklet_struct *t)
{
 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
  __tasklet_hi_schedule(t);
}
static inline __attribute__((always_inline)) void tasklet_disable_nosync(struct tasklet_struct *t)
{
 atomic_inc(&t->count);
 __asm__ __volatile__ ("" : : : "memory");
}
static inline __attribute__((always_inline)) void tasklet_disable(struct tasklet_struct *t)
{
 tasklet_disable_nosync(t);
 do { } while (0);
 __asm__ __volatile__("": : :"memory");
}
static inline __attribute__((always_inline)) void tasklet_enable(struct tasklet_struct *t)
{
 __asm__ __volatile__ ("" : : : "memory");
 atomic_dec(&t->count);
}
static inline __attribute__((always_inline)) void tasklet_hi_enable(struct tasklet_struct *t)
{
 __asm__ __volatile__ ("" : : : "memory");
 atomic_dec(&t->count);
}
extern void tasklet_kill(struct tasklet_struct *t);
extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
extern void tasklet_init(struct tasklet_struct *t,
    void (*func)(unsigned long), unsigned long data);
static inline __attribute__((always_inline)) unsigned long probe_irq_on(void)
{
 return 0;
}
static inline __attribute__((always_inline)) int probe_irq_off(unsigned long val)
{
 return 0;
}
static inline __attribute__((always_inline)) unsigned int probe_irq_mask(unsigned long val)
{
 return 0;
}
extern unsigned long isa_io_base;
extern unsigned long isa_mem_base;
extern unsigned long pci_dram_offset;
extern inline __attribute__((always_inline)) int in_8(volatile unsigned char *addr)
{
 int ret;
 __asm__ __volatile__(
  "lbz%U1%X1 %0,%1;\n"
  "twi 0,%0,0;\n"
  "isync" : "=r" (ret) : "m" (*addr));
 return ret;
}
extern inline __attribute__((always_inline)) void out_8(volatile unsigned char *addr, int val)
{
 __asm__ __volatile__("stb%U0%X0 %1,%0; eieio" : "=m" (*addr) : "r" (val));
}
extern inline __attribute__((always_inline)) int in_le16(volatile unsigned short *addr)
{
 int ret;
 __asm__ __volatile__("lhbrx %0,0,%1;\n"
        "twi 0,%0,0;\n"
        "isync" : "=r" (ret) :
         "r" (addr), "m" (*addr));
 return ret;
}
extern inline __attribute__((always_inline)) int in_be16(volatile unsigned short *addr)
{
 int ret;
 __asm__ __volatile__("lhz%U1%X1 %0,%1;\n"
        "twi 0,%0,0;\n"
        "isync" : "=r" (ret) : "m" (*addr));
 return ret;
}
extern inline __attribute__((always_inline)) void out_le16(volatile unsigned short *addr, int val)
{
 __asm__ __volatile__("sthbrx %1,0,%2; eieio" : "=m" (*addr) :
         "r" (val), "r" (addr));
}
extern inline __attribute__((always_inline)) void out_be16(volatile unsigned short *addr, int val)
{
 __asm__ __volatile__("sth%U0%X0 %1,%0; eieio" : "=m" (*addr) : "r" (val));
}
extern inline __attribute__((always_inline)) unsigned in_le32(volatile unsigned *addr)
{
 unsigned ret;
 __asm__ __volatile__("lwbrx %0,0,%1;\n"
        "twi 0,%0,0;\n"
        "isync" : "=r" (ret) :
        "r" (addr), "m" (*addr));
 return ret;
}
extern inline __attribute__((always_inline)) unsigned in_be32(volatile unsigned *addr)
{
 unsigned ret;
 __asm__ __volatile__("lwz%U1%X1 %0,%1;\n"
        "twi 0,%0,0;\n"
        "isync" : "=r" (ret) : "m" (*addr));
 return ret;
}
extern inline __attribute__((always_inline)) void out_le32(volatile unsigned *addr, int val)
{
 __asm__ __volatile__("stwbrx %1,0,%2; eieio" : "=m" (*addr) :
        "r" (val), "r" (addr));
}
extern inline __attribute__((always_inline)) void out_be32(volatile unsigned *addr, int val)
{
 __asm__ __volatile__("stw%U0%X0 %1,%0; eieio" : "=m" (*addr) : "r" (val));
}
static inline __attribute__((always_inline)) __u8 readb(volatile void *addr)
{
 return in_8(addr);
}
static inline __attribute__((always_inline)) void writeb(__u8 b, volatile void *addr)
{
 out_8(addr, b);
}
static inline __attribute__((always_inline)) __u16 readw(volatile void *addr)
{
 return in_le16(addr);
}
static inline __attribute__((always_inline)) __u32 readl(volatile void *addr)
{
 return in_le32(addr);
}
static inline __attribute__((always_inline)) void writew(__u16 b, volatile void *addr)
{
 out_le16(addr, b);
}
static inline __attribute__((always_inline)) void writel(__u32 b, volatile void *addr)
{
 out_le32(addr, b);
}
static inline __attribute__((always_inline)) __u8 __raw_readb(const volatile void *addr)
{
 return *( volatile __u8 *)(addr);
}
static inline __attribute__((always_inline)) __u16 __raw_readw(const volatile void *addr)
{
 return *( volatile __u16 *)(addr);
}
static inline __attribute__((always_inline)) __u32 __raw_readl(const volatile void *addr)
{
 return *( volatile __u32 *)(addr);
}
static inline __attribute__((always_inline)) void __raw_writeb(__u8 b, volatile void *addr)
{
 *( volatile __u8 *)(addr) = b;
}
static inline __attribute__((always_inline)) void __raw_writew(__u16 b, volatile void *addr)
{
 *( volatile __u16 *)(addr) = b;
}
static inline __attribute__((always_inline)) void __raw_writel(__u32 b, volatile void *addr)
{
 *( volatile __u32 *)(addr) = b;
}
extern void _insb(volatile u8 *port, void *buf, int ns);
extern void _outsb(volatile u8 *port, const void *buf, int ns);
extern void _insw(volatile u16 *port, void *buf, int ns);
extern void _outsw(volatile u16 *port, const void *buf, int ns);
extern void _insl(volatile u32 *port, void *buf, int nl);
extern void _outsl(volatile u32 *port, const void *buf, int nl);
extern void _insw_ns(volatile u16 *port, void *buf, int ns);
extern void _outsw_ns(volatile u16 *port, const void *buf, int ns);
extern void _insl_ns(volatile u32 *port, void *buf, int nl);
extern void _outsl_ns(volatile u32 *port, const void *buf, int nl);
static inline __attribute__((always_inline)) void memset_io(volatile void *addr, unsigned char val, int count)
{
 memset((void *)addr, val, count);
}
static inline __attribute__((always_inline)) void memcpy_fromio(void *dst,const volatile void *src, int count)
{
 memcpy(dst, (void *) src, count);
}
static inline __attribute__((always_inline)) void memcpy_toio(volatile void *dst, const void *src, int count)
{
 memcpy((void *) dst, src, count);
}
extern void *__ioremap(phys_addr_t address, unsigned long size,
         unsigned long flags);
extern void *ioremap(phys_addr_t address, unsigned long size);
extern void iounmap(volatile void *addr);
extern unsigned long iopa(unsigned long addr);
extern unsigned long mm_ptov(unsigned long addr) __attribute__((__const__));
extern void io_block_mapping(unsigned long virt, phys_addr_t phys,
        unsigned int size, int flags);
extern inline __attribute__((always_inline)) unsigned long virt_to_bus(volatile void * address)
{
        if (address == (void *)0)
  return 0;
        return (unsigned long)address - 0xc0000000 + pci_dram_offset;
}
extern inline __attribute__((always_inline)) void * bus_to_virt(unsigned long address)
{
        if (address == 0)
  return ((void *)0);
        return (void *)(address - pci_dram_offset + 0xc0000000);
}
extern inline __attribute__((always_inline)) unsigned long virt_to_phys(volatile void * address)
{
 return (unsigned long) address - 0xc0000000;
}
extern inline __attribute__((always_inline)) void * phys_to_virt(unsigned long address)
{
 return (void *) (address + 0xc0000000);
}
extern inline __attribute__((always_inline)) void eieio(void)
{
 __asm__ __volatile__ ("eieio" : : : "memory");
}
static inline __attribute__((always_inline)) int check_signature(volatile void * io_addr,
 const unsigned char *signature, int length)
{
 int retval = 0;
 do {
  if (readb(io_addr) != *signature)
   goto out;
  io_addr++;
  signature++;
  length--;
 } while (length);
 retval = 1;
out:
 return retval;
}
static inline __attribute__((always_inline)) unsigned int ioread8(void *addr)
{
 return readb(addr);
}
static inline __attribute__((always_inline)) unsigned int ioread16(void *addr)
{
 return readw(addr);
}
static inline __attribute__((always_inline)) unsigned int ioread32(void *addr)
{
 return readl(addr);
}
static inline __attribute__((always_inline)) void iowrite8(u8 val, void *addr)
{
 writeb(val, addr);
}
static inline __attribute__((always_inline)) void iowrite16(u16 val, void *addr)
{
 writew(val, addr);
}
static inline __attribute__((always_inline)) void iowrite32(u32 val, void *addr)
{
 writel(val, addr);
}
static inline __attribute__((always_inline)) void ioread8_rep(void *addr, void *dst, unsigned long count)
{
 _insb(addr, dst, count);
}
static inline __attribute__((always_inline)) void ioread16_rep(void *addr, void *dst, unsigned long count)
{
 _insw_ns(addr, dst, count);
}
static inline __attribute__((always_inline)) void ioread32_rep(void *addr, void *dst, unsigned long count)
{
 _insl_ns(addr, dst, count);
}
static inline __attribute__((always_inline)) void iowrite8_rep(void *addr, const void *src, unsigned long count)
{
 _outsb(addr, src, count);
}
static inline __attribute__((always_inline)) void iowrite16_rep(void *addr, const void *src, unsigned long count)
{
 _outsw_ns(addr, src, count);
}
static inline __attribute__((always_inline)) void iowrite32_rep(void *addr, const void *src, unsigned long count)
{
 _outsl_ns(addr, src, count);
}
extern void *ioport_map(unsigned long port, unsigned int nr);
extern void ioport_unmap(void *);
struct pci_dev;
extern void *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
extern void pci_iounmap(struct pci_dev *dev, void *);
static int random_read_wakeup_thresh = 64;
static int random_write_wakeup_thresh = 128;
static int trickle_thresh = 512 * 7;
static __typeof__(int) per_cpu__trickle_count = 0;
static struct poolinfo {
 int poolwords;
 int tap1, tap2, tap3, tap4, tap5;
} poolinfo_table[] = {
 { 2048, 1638, 1231, 819, 411, 1 },
 { 1024, 817, 615, 412, 204, 1 },
 { 512, 411, 308, 208, 104, 1 },
 { 256, 205, 155, 101, 52, 1 },
 { 128, 103, 76, 51, 25, 1 },
 { 64, 52, 39, 26, 14, 1 },
 { 32, 26, 20, 14, 7, 1 },
 { 0, 0, 0, 0, 0, 0 },
};
static struct entropy_store *random_state;
static struct entropy_store *sec_random_state;
static struct entropy_store *urandom_state;
static wait_queue_head_t random_read_wait = { .lock = (spinlock_t) { }, .task_list = { &(random_read_wait).task_list, &(random_read_wait).task_list } };
static wait_queue_head_t random_write_wait = { .lock = (spinlock_t) { }, .task_list = { &(random_write_wait).task_list, &(random_write_wait).task_list } };
static inline __attribute__((always_inline)) __u32 rotate_left(int i, __u32 word)
{
 return (word << i) | (word >> (32 - i));
}
static inline __attribute__((always_inline)) __u32 int_ln_12bits(__u32 word)
{
 word |= word >> 8;
 word |= word >> 4;
 word |= word >> 2;
 word |= word >> 1;
 word >>= 1;
 word -= (word >> 1) & 0x555;
 word = (word & 0x333) + ((word >> 2) & 0x333);
 word += (word >> 4);
 word += (word >> 8);
 return word & 15;
}
struct entropy_store {
 struct poolinfo poolinfo;
 __u32 *pool;
 const char *name;
 spinlock_t lock ;
 unsigned add_ptr;
 int entropy_count;
 int input_rotate;
};
static void __add_entropy_words(struct entropy_store *r, const __u32 *in,
    int nwords, __u32 out[16])
{
 static __u32 const twist_table[8] = {
  0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
  0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
 unsigned long i, add_ptr, tap1, tap2, tap3, tap4, tap5;
 int new_rotate, input_rotate;
 int wordmask = r->poolinfo.poolwords - 1;
 __u32 w, next_w;
 unsigned long flags;
 tap1 = r->poolinfo.tap1;
 tap2 = r->poolinfo.tap2;
 tap3 = r->poolinfo.tap3;
 tap4 = r->poolinfo.tap4;
 tap5 = r->poolinfo.tap5;
 next_w = *in++;
 do { local_irq_save_ptr(&flags); do { } while (0); do { (void)(&r->lock); } while(0); (void)0; } while (0);
 prefetch_range(r->pool, wordmask);
 input_rotate = r->input_rotate;
 add_ptr = r->add_ptr;
 while (nwords--) {
  w = rotate_left(input_rotate, next_w);
  if (nwords > 0)
   next_w = *in++;
  i = add_ptr = (add_ptr - 1) & wordmask;
  new_rotate = input_rotate + 14;
  if (i)
   new_rotate = input_rotate + 7;
  input_rotate = new_rotate & 31;
  w ^= r->pool[(i + tap1) & wordmask];
  w ^= r->pool[(i + tap2) & wordmask];
  w ^= r->pool[(i + tap3) & wordmask];
  w ^= r->pool[(i + tap4) & wordmask];
  w ^= r->pool[(i + tap5) & wordmask];
  w ^= r->pool[i];
  r->pool[i] = (w >> 3) ^ twist_table[w & 7];
 }
 r->input_rotate = input_rotate;
 r->add_ptr = add_ptr;
 if (out) {
  for (i = 0; i < 16; i++) {
   out[i] = r->pool[add_ptr];
   add_ptr = (add_ptr - 1) & wordmask;
  }
 }
 do { do { (void)(&r->lock); } while(0); asm volatile("mtmsr %0" : : "r" (flags)); do { } while (0); (void)0; } while (0);
}
static inline __attribute__((always_inline)) void add_entropy_words(struct entropy_store *r, const __u32 *in,
         int nwords)
{
 __add_entropy_words(r, in, nwords, ((void *)0));
}
static void credit_entropy_store(struct entropy_store *r, int nbits)
{
 unsigned long flags;
 do { local_irq_save_ptr(&flags); do { } while (0); do { (void)(&r->lock); } while(0); (void)0; } while (0);
 if (r->entropy_count + nbits < 0) {
  do {} while (0);
  r->entropy_count = 0;
 } else if (r->entropy_count + nbits > r->poolinfo.poolwords*32) {
  r->entropy_count = r->poolinfo.poolwords*32;
 } else {
  r->entropy_count += nbits;
  if (nbits)
   do {} while (0);
 }
 do { do { (void)(&r->lock); } while(0); asm volatile("mtmsr %0" : : "r" (flags)); do { } while (0); (void)0; } while (0);
}
struct sample {
 __u32 data[2];
 int credit;
};
static struct sample *batch_entropy_pool, *batch_entropy_copy;
static int batch_head, batch_tail;
static int batch_max;
static void batch_entropy_process(void *private_);
static struct work_struct batch_work = { .entry = { &(batch_work).entry, &(batch_work).entry }, .func = (batch_entropy_process), .data = (((void *)0)), .timer = { .function = (((void *)0)), .expires = (0), .data = (0), .base = ((void *)0), .magic = 0x4b87ad6e, .lock = (spinlock_t) { }, }, };
static void batch_entropy_store(u32 a, u32 b, int num)
{
 int new;
 if (!batch_max)
  return;
 batch_entropy_pool[batch_head].data[0] = a;
 batch_entropy_pool[batch_head].data[1] = b;
 batch_entropy_pool[batch_head].credit = num;
 if (((batch_head - batch_tail) & (batch_max - 1)) >= (batch_max / 2))
  schedule_delayed_work(&batch_work, 1);
 new = (batch_head + 1) & (batch_max - 1);
 if (new == batch_tail)
  do {} while (0);
 else
  batch_head = new;
}
static void batch_entropy_process(void *private_)
{
 struct entropy_store *r = (struct entropy_store *) private_, *p;
 int max_entropy = r->poolinfo.poolwords*32;
 unsigned head, tail;
 memcpy(batch_entropy_copy, batch_entropy_pool,
        batch_max * sizeof(struct sample));
 head = batch_head;
 tail = batch_tail;
 batch_tail = batch_head;
 p = r;
 while (head != tail) {
  if (r->entropy_count >= max_entropy) {
   r = (r == sec_random_state) ? random_state :
    sec_random_state;
   max_entropy = r->poolinfo.poolwords*32;
  }
  add_entropy_words(r, batch_entropy_copy[tail].data, 2);
  credit_entropy_store(r, batch_entropy_copy[tail].credit);
  tail = (tail + 1) & (batch_max - 1);
 }
 if (p->entropy_count >= random_read_wakeup_thresh)
  __wake_up(&random_read_wait, 1, 1, ((void *)0));
}
struct timer_rand_state {
 cycles_t last_time;
 long last_delta,last_delta2;
 unsigned dont_count_entropy:1;
};
static struct timer_rand_state input_timer_state;
static struct timer_rand_state extract_timer_state;
static struct timer_rand_state *irq_timer_state[256];
static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
{
 cycles_t data;
 long delta, delta2, delta3, time;
 int entropy = 0;
 do { } while (0);
 if (random_state->entropy_count > trickle_thresh &&
     (per_cpu__trickle_count++ & 0xfff))
  goto out;
 time = jiffies;
 if (!state->dont_count_entropy) {
  delta = time - state->last_time;
  state->last_time = time;
  delta2 = delta - state->last_delta;
  state->last_delta = delta;
  delta3 = delta2 - state->last_delta2;
  state->last_delta2 = delta2;
  if (delta < 0)
   delta = -delta;
  if (delta2 < 0)
   delta2 = -delta2;
  if (delta3 < 0)
   delta3 = -delta3;
  if (delta > delta2)
   delta = delta2;
  if (delta > delta3)
   delta = delta3;
  delta >>= 1;
  delta &= (1 << 12) - 1;
  entropy = int_ln_12bits(delta);
 }
 data = get_cycles();
 if (data)
  num ^= (u32)((data >> 31) >> 1);
 else
  data = time;
 batch_entropy_store(num, data, entropy);
out:
 do { } while (0);
}
extern void add_input_randomness(unsigned int type, unsigned int code,
     unsigned int value)
{
 static unsigned char last_value;
 if (value == last_value)
  return;
 do {} while (0);
 last_value = value;
 add_timer_randomness(&input_timer_state,
        (type << 4) ^ code ^ (code >> 4) ^ value);
}
void add_interrupt_randomness(int irq)
{
 if (irq >= 256 || irq_timer_state[irq] == 0)
  return;
 do {} while (0);
 add_timer_randomness(irq_timer_state[irq], 0x100 + irq);
}
void add_disk_randomness(struct gendisk *disk)
{
 if (!disk || !disk->random)
  return;
 do {} while (0);
 add_timer_randomness(disk->random,
        0x100 + (((disk->major) << 20) | (disk->first_minor)));
}
;
static ssize_t extract_entropy(struct entropy_store *r, void * buf,
          size_t nbytes, int flags);
static inline __attribute__((always_inline)) void xfer_secondary_pool(struct entropy_store *r,
           size_t nbytes, __u32 *tmp)
{
 if (r->entropy_count < nbytes * 8 &&
     r->entropy_count < r->poolinfo.poolwords*32) {
  int bytes = ({ int __x = (random_read_wakeup_thresh / 8); int __y = (({ int __x = (nbytes); int __y = ((5 + 80)); __x < __y ? __x: __y; })); __x > __y ? __x: __y; });
  do {} while (0);
  bytes=extract_entropy(random_state, tmp, bytes,
          4);
  add_entropy_words(r, tmp, (bytes + 3) / 4);
  credit_entropy_store(r, bytes*8);
 }
}
static ssize_t extract_entropy(struct entropy_store *r, void * buf,
          size_t nbytes, int flags)
{
 ssize_t ret, i;
 __u32 tmp[(5 + 80)], data[16];
 __u32 x;
 if (r->entropy_count > r->poolinfo.poolwords*32)
  r->entropy_count = r->poolinfo.poolwords*32;
 if (flags & 2)
  xfer_secondary_pool(r, nbytes, tmp);
 do {} while (0);
 if (flags & 4 && nbytes >= r->entropy_count / 8)
  nbytes = r->entropy_count / 8;
 if (r->entropy_count / 8 >= nbytes)
  r->entropy_count -= nbytes*8;
 else
  r->entropy_count = 0;
 if (r->entropy_count < random_write_wakeup_thresh)
  __wake_up(&random_write_wait, 1, 1, ((void *)0));
 do {} while (0);
 ret = 0;
 while (nbytes) {
  if ((flags & 1) && need_resched()) {
   if (signal_pending(current)) {
    if (ret == 0)
     ret = -512;
    break;
   }
   schedule();
  }
  tmp[0] = 0x67452301;
  tmp[1] = 0xefcdab89;
  tmp[2] = 0x98badcfe;
  tmp[3] = 0x10325476;
  tmp[4] = 0xc3d2e1f0;
  for (i = 0, x = 0; i < r->poolinfo.poolwords; i += 16, x+=2) {
   SHATransform(tmp, r->pool+i);
   add_entropy_words(r, &tmp[x%5], 1);
  }
  __add_entropy_words(r, &tmp[x%5], 1, data);
  SHATransform(tmp, data);
  for (i = 0; i < 5/2; i++)
   tmp[i] ^= tmp[i + (5 +1)/2];
  x = tmp[5/2];
  x ^= (x >> 16);
  ((__u16 *)tmp)[5 -1] = (__u16)x;
  i = ({ typeof(nbytes) _x = (nbytes); typeof(5*sizeof(__u32)/2) _y = (5*sizeof(__u32)/2); (void) (&_x == &_y); _x < _y ? _x : _y; });
  if (flags & 1) {
   i -= copy_to_user(buf, (__u8 const *)tmp, i);
   if (!i) {
    ret = -14;
    break;
   }
  } else
   memcpy(buf, (__u8 const *)tmp, i);
  nbytes -= i;
  buf += i;
  ret += i;
 }
 memset(tmp, 0, sizeof(tmp));
 return ret;
}
void get_random_bytes(void *buf, int nbytes)
{
 struct entropy_store *r = urandom_state;
 int flags = 2;
 if (!r)
  r = sec_random_state;
 if (!r) {
  r = random_state;
  flags = 0;
 }
 if (!r) {
  printk("<5>" "get_random_bytes called before "
       "random driver initialization\n");
  return;
 }
 extract_entropy(r, (char *) buf, nbytes, flags);
}
;
static void init_std_data(struct entropy_store *r)
{
 struct timeval tv;
 __u32 words[2];
 char *p;
 int i;
 do_gettimeofday(&tv);
 words[0] = tv.tv_sec;
 words[1] = tv.tv_usec;
 add_entropy_words(r, words, 2);
 p = (char *) &system_utsname;
 for (i = sizeof(system_utsname) / sizeof(words); i; i--) {
  memcpy(words, p, sizeof(words));
  add_entropy_words(r, words, sizeof(words)/4);
  p += sizeof(words);
 }
}
static int __attribute__ ((__section__ (".init.text"))) rand_initialize(void)
{
 init_std_data(urandom_state);
}
static initcall_t __initcall_rand_initialize __attribute__((__used__)) __attribute__((__section__(".initcall" "6" ".init"))) = rand_initialize;;