# 1 "net/ipv4/ip_output.c"
# 1 "/usr/local/src/blackfin/svn/linux-kernel/trunk//"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "./include/linux/autoconf.h" 1
# 1 "<command line>" 2
# 1 "net/ipv4/ip_output.c"
# 47 "net/ipv4/ip_output.c"
# 1 "include/asm/uaccess.h" 1
# 12 "include/asm/uaccess.h"
# 1 "include/linux/sched.h" 1



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



# 1 "include/asm/auxvec.h" 1
# 5 "include/linux/auxvec.h" 2
# 5 "include/linux/sched.h" 2
# 40 "include/linux/sched.h"
struct sched_param {
 int sched_priority;
};

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

# 1 "include/linux/capability.h" 1
# 16 "include/linux/capability.h"
# 1 "include/linux/types.h" 1
# 14 "include/linux/types.h"
# 1 "include/linux/posix_types.h" 1



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



# 1 "include/linux/compiler.h" 1
# 42 "include/linux/compiler.h"
# 1 "include/linux/compiler-gcc4.h" 1



# 1 "include/linux/compiler-gcc.h" 1
# 5 "include/linux/compiler-gcc4.h" 2
# 43 "include/linux/compiler.h" 2
# 5 "include/linux/stddef.h" 2
# 15 "include/linux/stddef.h"
enum {
 false = 0,
 true = 1
};
# 5 "include/linux/posix_types.h" 2
# 36 "include/linux/posix_types.h"
typedef struct {
 unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;
typedef int __kernel_mqd_t;

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

typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;
typedef unsigned short __kernel_old_dev_t;


typedef long long __kernel_loff_t;


typedef struct {

 int val[2];



} __kernel_fsid_t;
# 48 "include/linux/posix_types.h" 2
# 15 "include/linux/types.h" 2
# 1 "include/asm/types.h" 1
# 13 "include/asm/types.h"
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;
# 45 "include/asm/types.h"
typedef signed char s8;
typedef unsigned char u8;

typedef signed short s16;
typedef unsigned short u16;

typedef signed int s32;
typedef unsigned int u32;

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



typedef u32 dma_addr_t;
typedef u64 dma64_addr_t;
# 16 "include/linux/types.h" 2



typedef __u32 __kernel_dev_t;

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


typedef _Bool bool;

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



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




typedef __kernel_ssize_t ssize_t;




typedef __kernel_ptrdiff_t ptrdiff_t;




typedef __kernel_time_t time_t;




typedef __kernel_clock_t clock_t;




typedef __kernel_caddr_t caddr_t;



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


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




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



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


typedef __u64 uint64_t;
typedef __u64 u_int64_t;
typedef __s64 int64_t;
# 142 "include/linux/types.h"
typedef unsigned long sector_t;



typedef unsigned long blkcnt_t;
# 175 "include/linux/types.h"
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;

typedef __u64 __le64;
typedef __u64 __be64;



typedef unsigned gfp_t;




typedef u32 resource_size_t;




struct ustat {
 __kernel_daddr_t f_tfree;
 __kernel_ino_t f_tinode;
 char f_fname[6];
 char f_fpack[6];
};
# 17 "include/linux/capability.h" 2
# 32 "include/linux/capability.h"
typedef struct __user_cap_header_struct {
 __u32 version;
 int pid;
} *cap_user_header_t;

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



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

extern long do_no_restart_syscall(struct restart_block *parm);

# 1 "include/linux/bitops.h" 1
# 9 "include/linux/bitops.h"
# 1 "include/asm/bitops.h" 1
# 9 "include/asm/bitops.h"
# 1 "include/asm/byteorder.h" 1
# 9 "include/asm/byteorder.h"
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swahb32(__u32 xx)
{
 __u32 tmp;
 __asm__("%1 = %0 >> 8 (V);\n\t"
  "%0 = %0 << 8 (V);\n\t"
  "%0 = %0 | %1;\n\t"
  : "+d"(xx), "=&d"(tmp));
 return xx;
}

static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swahw32(__u32 xx)
{
 __u32 rv;
 __asm__("%0 = PACK(%1.L, %1.H);\n\t": "=d"(rv): "d"(xx));
 return rv;
}





static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 ___arch__swab16(__u16 xx)
{
 __u32 xw = xx;
 __asm__("%0 <<= 8;\n	%0.L = %0.L + %0.H (NS);\n": "+d"(xw));
 return (__u16)xw;
}
# 46 "include/asm/byteorder.h"
# 1 "include/linux/byteorder/little_endian.h" 1
# 12 "include/linux/byteorder/little_endian.h"
# 1 "include/linux/byteorder/swab.h" 1
# 133 "include/linux/byteorder/swab.h"
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 x)
{
 return ___arch__swab16(x);
}
static __inline__ __attribute__((always_inline)) __u16 __swab16p(const __u16 *x)
{
 return ___arch__swab16(*(x));
}
static __inline__ __attribute__((always_inline)) void __swab16s(__u16 *addr)
{
 do { *(addr) = ___arch__swab16(*((addr))); } while (0);
}

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


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

 __u32 h = x >> 32;
        __u32 l = x & ((1ULL<<32)-1);
        return (((__u64)__fswab32(l)) << 32) | ((__u64)(__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);
}
# 13 "include/linux/byteorder/little_endian.h" 2
# 43 "include/linux/byteorder/little_endian.h"
static inline __attribute__((always_inline)) __le64 __cpu_to_le64p(const __u64 *p)
{
 return ( __le64)*p;
}
static inline __attribute__((always_inline)) __u64 __le64_to_cpup(const __le64 *p)
{
 return ( __u64)*p;
}
static inline __attribute__((always_inline)) __le32 __cpu_to_le32p(const __u32 *p)
{
 return ( __le32)*p;
}
static inline __attribute__((always_inline)) __u32 __le32_to_cpup(const __le32 *p)
{
 return ( __u32)*p;
}
static inline __attribute__((always_inline)) __le16 __cpu_to_le16p(const __u16 *p)
{
 return ( __le16)*p;
}
static inline __attribute__((always_inline)) __u16 __le16_to_cpup(const __le16 *p)
{
 return ( __u16)*p;
}
static inline __attribute__((always_inline)) __be64 __cpu_to_be64p(const __u64 *p)
{
 return ( __be64)__swab64p(p);
}
static inline __attribute__((always_inline)) __u64 __be64_to_cpup(const __be64 *p)
{
 return __swab64p((__u64 *)p);
}
static inline __attribute__((always_inline)) __be32 __cpu_to_be32p(const __u32 *p)
{
 return ( __be32)__swab32p(p);
}
static inline __attribute__((always_inline)) __u32 __be32_to_cpup(const __be32 *p)
{
 return __swab32p((__u32 *)p);
}
static inline __attribute__((always_inline)) __be16 __cpu_to_be16p(const __u16 *p)
{
 return ( __be16)__swab16p(p);
}
static inline __attribute__((always_inline)) __u16 __be16_to_cpup(const __be16 *p)
{
 return __swab16p((__u16 *)p);
}
# 104 "include/linux/byteorder/little_endian.h"
# 1 "include/linux/byteorder/generic.h" 1
# 154 "include/linux/byteorder/generic.h"
extern __u32 ntohl(__be32);
extern __be32 htonl(__u32);
extern __u16 ntohs(__be16);
extern __be16 htons(__u16);
# 105 "include/linux/byteorder/little_endian.h" 2
# 47 "include/asm/byteorder.h" 2
# 10 "include/asm/bitops.h" 2
# 1 "include/asm/system.h" 1
# 40 "include/asm/system.h"
# 1 "include/linux/linkage.h" 1



# 1 "include/asm/linkage.h" 1
# 5 "include/linux/linkage.h" 2
# 41 "include/asm/system.h" 2






extern unsigned long irq_flags;
# 146 "include/asm/system.h"
struct __xchg_dummy {
 unsigned long a[100];
};


static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void *ptr,
       int size)
{
 unsigned long tmp = 0;
 unsigned long flags = 0;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);

 switch (size) {
 case 1:
  __asm__ __volatile__
   ("%0 = b%2 (z);\n\t"
    "b%2 = %1;\n\t"
    : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
  break;
 case 2:
  __asm__ __volatile__
   ("%0 = w%2 (z);\n\t"
    "w%2 = %1;\n\t"
    : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
  break;
 case 4:
  __asm__ __volatile__
   ("%0 = %2;\n\t"
    "%2 = %1;\n\t"
    : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
  break;
 }
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
 return tmp;
}






static inline __attribute__((always_inline)) unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
          unsigned long new, int size)
{
 unsigned long tmp = 0;
 unsigned long flags = 0;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);

 switch (size) {
 case 1:
  __asm__ __volatile__
   ("%0 = b%3 (z);\n\t"
    "CC = %1 == %0;\n\t"
    "IF !CC JUMP 1f;\n\t"
    "b%3 = %2;\n\t"
    "1:\n\t"
    : "=&d" (tmp) : "d" (old), "d" (new), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
  break;
 case 2:
  __asm__ __volatile__
   ("%0 = w%3 (z);\n\t"
    "CC = %1 == %0;\n\t"
    "IF !CC JUMP 1f;\n\t"
    "w%3 = %2;\n\t"
    "1:\n\t"
    : "=&d" (tmp) : "d" (old), "d" (new), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
  break;
 case 4:
  __asm__ __volatile__
   ("%0 = %3;\n\t"
    "CC = %1 == %0;\n\t"
    "IF !CC JUMP 1f;\n\t"
    "%3 = %2;\n\t"
    "1:\n\t"
    : "=&d" (tmp) : "d" (old), "d" (new), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
  break;
 }
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
 return tmp;
}
# 240 "include/asm/system.h"
# 1 "include/asm/blackfin.h" 1
# 9 "include/asm/blackfin.h"
# 1 "include/asm/macros.h" 1
# 10 "include/asm/blackfin.h" 2
# 1 "include/asm/mach/blackfin.h" 1
# 37 "include/asm/mach/blackfin.h"
# 1 "include/asm/mach/bf537.h" 1
# 35 "include/asm/mach/bf537.h"
# 1 "include/linux/config.h" 1





# 1 "include/linux/autoconf.h" 1
# 7 "include/linux/config.h" 2
# 36 "include/asm/mach/bf537.h" 2
# 38 "include/asm/mach/blackfin.h" 2
# 1 "include/asm/mach/mem_map.h" 1
# 39 "include/asm/mach/blackfin.h" 2
# 1 "include/asm/mach/defBF534.h" 1
# 36 "include/asm/mach/defBF534.h"
# 1 "include/asm/mach-common/def_LPBlackfin.h" 1
# 37 "include/asm/mach-common/def_LPBlackfin.h"
# 1 "include/asm/mach/anomaly.h" 1
# 38 "include/asm/mach-common/def_LPBlackfin.h" 2
# 37 "include/asm/mach/defBF534.h" 2
# 40 "include/asm/mach/blackfin.h" 2
# 1 "include/asm/mach/anomaly.h" 1
# 41 "include/asm/mach/blackfin.h" 2


# 1 "include/asm/mach/defBF537.h" 1
# 36 "include/asm/mach/defBF537.h"
# 1 "include/asm/mach/defBF537.h" 1
# 37 "include/asm/mach/defBF537.h" 2


# 1 "include/asm/mach-common/cdef_LPBlackfin.h" 1
# 40 "include/asm/mach/defBF537.h" 2
# 44 "include/asm/mach/blackfin.h" 2



# 1 "include/asm/mach/cdefBF534.h" 1
# 41 "include/asm/mach/cdefBF534.h"
# 1 "include/asm/system.h" 1
# 42 "include/asm/mach/cdefBF534.h" 2
# 50 "include/asm/mach/cdefBF534.h"
static __inline__ __attribute__((always_inline)) void bfin_write_VR_CTL(unsigned int val)
{
 unsigned long flags, iwr;

 ({ __asm__ __volatile__ ( "w[%0] = %1;\n\t" : : "a"(0xFFC00008) , "d"(val) : "memory");});
 __builtin_bfin_ssync();

 iwr = ({ unsigned __v; __asm__ __volatile__ ( "%0 = [%1];\n\t" : "=d"(__v) : "a"(0xFFC00124)); __v; });

 ({ __asm__ __volatile__ ( "[%0] = %1;\n\t" : : "a"(0xFFC00124) , "d"((1 << ((0)&0x1F))) : "memory");});
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 asm("IDLE;");
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
 ({ __asm__ __volatile__ ( "[%0] = %1;\n\t" : : "a"(0xFFC00124) , "d"(iwr) : "memory");});
}
# 48 "include/asm/mach/blackfin.h" 2
# 74 "include/asm/mach/blackfin.h"
# 1 "include/asm/mach/cdefBF537.h" 1
# 75 "include/asm/mach/blackfin.h" 2
# 11 "include/asm/blackfin.h" 2
# 1 "include/asm/bfin-global.h" 1
# 36 "include/asm/bfin-global.h"
# 1 "include/asm-generic/sections.h" 1





extern char _text[], _stext[], _etext[];
extern char _data[], _sdata[], _edata[];
extern char __bss_start[], __bss_stop[];
extern char __init_begin[], __init_end[];
extern char _sinittext[], _einittext[];
extern char _sextratext[] __attribute__((weak));
extern char _eextratext[] __attribute__((weak));
extern char _end[];
extern char __per_cpu_start[], __per_cpu_end[];
extern char __kprobes_text_start[], __kprobes_text_end[];
extern char __initdata_begin[], __initdata_end[];
extern char __start_rodata[], __end_rodata[];
# 37 "include/asm/bfin-global.h" 2
# 1 "include/asm/ptrace.h" 1
# 24 "include/asm/ptrace.h"
struct pt_regs {
 long orig_pc;
 long ipend;
 long seqstat;
 long rete;
 long retn;
 long retx;
 long pc;
 long rets;
 long reserved;
 long astat;
 long lb1;
 long lb0;
 long lt1;
 long lt0;
 long lc1;
 long lc0;
 long a1w;
 long a1x;
 long a0w;
 long a0x;
 long b3;
 long b2;
 long b1;
 long b0;
 long l3;
 long l2;
 long l1;
 long l0;
 long m3;
 long m2;
 long m1;
 long m0;
 long i3;
 long i2;
 long i1;
 long i0;
 long usp;
 long fp;
 long p5;
 long p4;
 long p3;
 long p2;
 long p1;
 long p0;
 long r7;
 long r6;
 long r5;
 long r4;
 long r3;
 long r2;
 long r1;
 long r0;
 long orig_r0;
 long orig_p0;
 long syscfg;
};
# 99 "include/asm/ptrace.h"
extern void show_regs(struct pt_regs *);
# 38 "include/asm/bfin-global.h" 2
# 1 "include/asm/user.h" 1
# 10 "include/asm/user.h"
# 1 "include/asm/page.h" 1
# 12 "include/asm/page.h"
# 1 "include/asm/setup.h" 1
# 13 "include/asm/page.h" 2
# 28 "include/asm/page.h"
typedef struct {
 unsigned long pte;
} pte_t;
typedef struct {
 unsigned long pmd[16];
} pmd_t;
typedef struct {
 unsigned long pgd;
} pgd_t;
typedef struct {
 unsigned long pgprot;
} pgprot_t;
# 54 "include/asm/page.h"
extern unsigned long memory_start;
extern unsigned long memory_end;



# 1 "include/asm/page_offset.h" 1
# 60 "include/asm/page.h" 2
# 1 "include/asm/io.h" 1
# 97 "include/asm/io.h"
extern void outsb(void *port, const void *addr, unsigned long count);
extern void outsw(void *port, const void *addr, unsigned long count);
extern void outsl(void *port, const void *addr, unsigned long count);

extern void insb(const void *port, void *addr, unsigned long count);
extern void insw(const void *port, void *addr, unsigned long count);
extern void insl(const void *port, void *addr, unsigned long count);

extern void *__ioremap(unsigned long physaddr, unsigned long size,
         int cacheflag);
extern void iounmap(void *addr);

static inline __attribute__((always_inline)) void *ioremap(unsigned long physaddr, unsigned long size)
{
 return __ioremap(physaddr, size, 1);
}
static inline __attribute__((always_inline)) void *ioremap_nocache(unsigned long physaddr,
         unsigned long size)
{
 return __ioremap(physaddr, size, 1);
}

extern void blkfin_inv_cache_all(void);
# 61 "include/asm/page.h" 2
# 84 "include/asm/page.h"
# 1 "include/asm-generic/page.h" 1
# 10 "include/asm-generic/page.h"
static __inline__ __attribute__((always_inline)) __attribute__((__const__)) int get_order(unsigned long size)
{
 int order;

 size = (size - 1) >> (12 - 1);
 order = -1;
 do {
  size >>= 1;
  order++;
 } while (size);
 return order;
}
# 85 "include/asm/page.h" 2
# 11 "include/asm/user.h" 2
# 38 "include/asm/user.h"
struct user_bfinfp_struct {
};




struct user_regs_struct {
 long r0, r1, r2, r3, r4, r5, r6, r7;
 long p0, p1, p2, p3, p4, p5, usp, fp;
 long i0, i1, i2, i3;
 long l0, l1, l2, l3;
 long b0, b1, b2, b3;
 long m0, m1, m2, m3;
 long a0w, a1w;
 long a0x, a1x;
 unsigned long rets;
 unsigned long astat;
 unsigned long pc;
 unsigned long orig_p0;
};





struct user {



 struct user_regs_struct regs;


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



 long int signal;
 int reserved;
 struct user_regs_struct *u_ar0;


 unsigned long magic;
 char u_comm[32];
};
# 39 "include/asm/bfin-global.h" 2
# 49 "include/asm/bfin-global.h"
extern unsigned long get_cclk(void);
extern unsigned long get_sclk(void);

extern void dump_thread(struct pt_regs *regs, struct user *dump);
extern void dump_bfin_regs(struct pt_regs *fp, void *retaddr);
extern void dump_bfin_trace_buffer(void);

extern int init_arch_irq(void);
extern void bfin_reset(void);
extern void _cplb_hdr(void);

extern void bfin_icache_init(void);
extern void bfin_dcache_init(void);
extern int read_iloc(void);
extern int bfin_console_init(void);
extern void lower_to_irq14(void);
extern void init_dma(void);
extern void program_IAR(void);
extern void evt14_softirq(void);
extern void asm_do_IRQ(unsigned int irq, struct pt_regs *regs);
extern void bfin_gpio_interrupt_setup(int irq, int irq_pfx, int type);

extern void *l1_data_A_sram_alloc(size_t);
extern void *l1_data_B_sram_alloc(size_t);
extern void *l1_inst_sram_alloc(size_t);
extern void *l1_data_sram_zalloc(size_t);
extern int l1_data_A_sram_free(const void*);
extern int l1_data_B_sram_free(const void*);
extern int l1_inst_sram_free(const void*);
extern int l1_data_sram_free(const void*);
extern int sram_free(const void*);





extern void *sram_alloc_with_lsl(size_t, unsigned long);
extern int sram_free_with_lsl(const void*);

extern void led_on(int);
extern void led_off(int);
extern void led_toggle(int);
extern void led_disp_num(int);
extern void led_toggle_num(int);

extern char *bfin_board_name __attribute__ ((weak));
extern unsigned long wall_jiffies;
extern unsigned long memory_end;
extern unsigned long memory_mtd_end;
extern unsigned long memory_mtd_start;
extern unsigned long mtd_size;
extern unsigned long ipdt_table[];
extern unsigned long dpdt_table[];
extern unsigned long icplb_table[];
extern unsigned long dcplb_table[];

extern unsigned long ipdt_swapcount_table[];
extern unsigned long dpdt_swapcount_table[];

extern unsigned long table_start, table_end;

extern struct file_operations dpmc_fops;
extern char _start;
extern unsigned long _ramstart, _ramend, _rambase;
extern unsigned long memory_start, memory_end;
extern unsigned long memory_mtd_end;
extern char _stext_l1[], _etext_l1[], _sdata_l1[], _edata_l1[], _sbss_l1[],
    _ebss_l1[], _l1_lma_start[];
# 12 "include/asm/blackfin.h" 2
# 241 "include/asm/system.h" 2

 struct task_struct *resume(struct task_struct *prev, struct task_struct *next);
# 11 "include/asm/bitops.h" 2



# 1 "include/asm-generic/bitops/ffs.h" 1
# 12 "include/asm-generic/bitops/ffs.h"
static inline __attribute__((always_inline)) int 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;
}
# 15 "include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/__ffs.h" 1
# 12 "include/asm-generic/bitops/__ffs.h"
static inline __attribute__((always_inline)) unsigned long __ffs(unsigned long word)
{
 int num = 0;







 if ((word & 0xffff) == 0) {
  num += 16;
  word >>= 16;
 }
 if ((word & 0xff) == 0) {
  num += 8;
  word >>= 8;
 }
 if ((word & 0xf) == 0) {
  num += 4;
  word >>= 4;
 }
 if ((word & 0x3) == 0) {
  num += 2;
  word >>= 2;
 }
 if ((word & 0x1) == 0)
  num += 1;
 return num;
}
# 16 "include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/sched.h" 1
# 13 "include/asm-generic/bitops/sched.h"
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;



}
# 17 "include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/ffz.h" 1
# 18 "include/asm/bitops.h" 2

static __inline__ __attribute__((always_inline)) void set_bit(int nr, volatile unsigned long *addr)
{
 int *a = (int *)addr;
 int mask;
 unsigned long flags;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 *a |= mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static __inline__ __attribute__((always_inline)) void __set_bit(int nr, volatile unsigned long *addr)
{
 int *a = (int *)addr;
 int mask;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 *a |= mask;
}







static __inline__ __attribute__((always_inline)) void clear_bit(int nr, volatile unsigned long *addr)
{
 int *a = (int *)addr;
 int mask;
 unsigned long flags;
 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 *a &= ~mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static __inline__ __attribute__((always_inline)) void __clear_bit(int nr, volatile unsigned long *addr)
{
 int *a = (int *)addr;
 int mask;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 *a &= ~mask;
}

static __inline__ __attribute__((always_inline)) void change_bit(int nr, volatile unsigned long *addr)
{
 int mask, flags;
 unsigned long *ADDR = (unsigned long *)addr;

 ADDR += nr >> 5;
 mask = 1 << (nr & 31);
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 *ADDR ^= mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static __inline__ __attribute__((always_inline)) void __change_bit(int nr, volatile unsigned long *addr)
{
 int mask;
 unsigned long *ADDR = (unsigned long *)addr;

 ADDR += nr >> 5;
 mask = 1 << (nr & 31);
 *ADDR ^= mask;
}

static __inline__ __attribute__((always_inline)) int test_and_set_bit(int nr, void *addr)
{
 int mask, retval;
 volatile unsigned int *a = (volatile unsigned int *)addr;
 unsigned long flags;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 retval = (mask & *a) != 0;
 *a |= mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);

 return retval;
}

static __inline__ __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile unsigned long *addr)
{
 int mask, retval;
 volatile unsigned int *a = (volatile unsigned int *)addr;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 retval = (mask & *a) != 0;
 *a |= mask;
 return retval;
}

static __inline__ __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile unsigned long *addr)
{
 int mask, retval;
 volatile unsigned int *a = (volatile unsigned int *)addr;
 unsigned long flags;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 retval = (mask & *a) != 0;
 *a &= ~mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);

 return retval;
}

static __inline__ __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile unsigned long *addr)
{
 int mask, retval;
 volatile unsigned int *a = (volatile unsigned int *)addr;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 retval = (mask & *a) != 0;
 *a &= ~mask;
 return retval;
}

static __inline__ __attribute__((always_inline)) int test_and_change_bit(int nr, volatile unsigned long *addr)
{
 int mask, retval;
 volatile unsigned int *a = (volatile unsigned int *)addr;
 unsigned long flags;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 retval = (mask & *a) != 0;
 *a ^= mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
 return retval;
}

static __inline__ __attribute__((always_inline)) int __test_and_change_bit(int nr,
         volatile unsigned long *addr)
{
 int mask, retval;
 volatile unsigned int *a = (volatile unsigned int *)addr;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 retval = (mask & *a) != 0;
 *a ^= mask;
 return retval;
}




static __inline__ __attribute__((always_inline)) int __constant_test_bit(int nr, const void *addr)
{
 return ((1UL << (nr & 31)) &
  (((const volatile unsigned int *)addr)[nr >> 5])) != 0;
}

static __inline__ __attribute__((always_inline)) int __test_bit(int nr, const void *addr)
{
 int *a = (int *)addr;
 int mask;

 a += nr >> 5;
 mask = 1 << (nr & 0x1f);
 return ((mask & *a) != 0);
}






# 1 "include/asm-generic/bitops/find.h" 1



extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
  size, unsigned long offset);

extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
  long size, unsigned long offset);
# 201 "include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/hweight.h" 1





extern unsigned int hweight32(unsigned int w);
extern unsigned int hweight16(unsigned int w);
extern unsigned int hweight8(unsigned int w);
extern unsigned long hweight64(__u64 w);
# 202 "include/asm/bitops.h" 2

# 1 "include/asm-generic/bitops/ext2-atomic.h" 1
# 204 "include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/ext2-non-atomic.h" 1



# 1 "include/asm-generic/bitops/le.h" 1
# 5 "include/asm-generic/bitops/ext2-non-atomic.h" 2
# 205 "include/asm/bitops.h" 2

# 1 "include/asm-generic/bitops/minix.h" 1
# 207 "include/asm/bitops.h" 2



# 1 "include/asm-generic/bitops/fls.h" 1
# 12 "include/asm-generic/bitops/fls.h"
static inline __attribute__((always_inline)) int 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;
}
# 211 "include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/fls64.h" 1





static inline __attribute__((always_inline)) int fls64(__u64 x)
{
 __u32 h = x >> 32;
 if (h)
  return fls(h) + 32;
 return fls(x);
}
# 212 "include/asm/bitops.h" 2
# 10 "include/linux/bitops.h" 2

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

 order = fls(count);
 return order;
}

static __inline__ __attribute__((always_inline)) int get_count_order(unsigned int count)
{
 int order;

 order = fls(count) - 1;
 if (count & (count - 1))
  order++;
 return order;
}

static inline __attribute__((always_inline)) unsigned long hweight_long(unsigned long w)
{
 return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
}







static inline __attribute__((always_inline)) __u32 rol32(__u32 word, unsigned int shift)
{
 return (word << shift) | (word >> (32 - shift));
}







static inline __attribute__((always_inline)) __u32 ror32(__u32 word, unsigned int shift)
{
 return (word >> shift) | (word << (32 - shift));
}

static inline __attribute__((always_inline)) unsigned fls_long(unsigned long l)
{
 if (sizeof(l) == 4)
  return fls(l);
 return fls64(l);
}
# 21 "include/linux/thread_info.h" 2
# 1 "include/asm/thread_info.h" 1
# 32 "include/asm/thread_info.h"
# 1 "include/asm/entry.h" 1
# 33 "include/asm/thread_info.h" 2
# 1 "include/asm/l1layout.h" 1
# 16 "include/asm/l1layout.h"
struct l1_scratch_task_info
{

 void *stack_start;



 void *lowest_sp;
};
# 34 "include/asm/thread_info.h" 2
# 45 "include/asm/thread_info.h"
typedef unsigned long mm_segment_t;






struct thread_info {
 struct task_struct *task;
 struct exec_domain *exec_domain;
 unsigned long flags;
 int cpu;
 int preempt_count;
 mm_segment_t addr_limit;
 struct restart_block restart_block;
 struct l1_scratch_task_info l1_task_info;
};
# 87 "include/asm/thread_info.h"
static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
    __attribute__ ((__const__));




static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
{
 struct thread_info *ti;
      __asm__("%0 = sp;": "=&d"(ti):
 );
 return (struct thread_info *)((long)ti & ~8191UL);
}
# 22 "include/linux/thread_info.h" 2
# 30 "include/linux/thread_info.h"
static inline __attribute__((always_inline)) void set_ti_thread_flag(struct thread_info *ti, int flag)
{
 set_bit(flag,&ti->flags);
}

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

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

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

static inline __attribute__((always_inline)) int test_ti_thread_flag(struct thread_info *ti, int flag)
{
 return (__builtin_constant_p(flag) ? __constant_test_bit((flag),(&ti->flags)) : __test_bit((flag),(&ti->flags)));
}
# 10 "include/linux/preempt.h" 2
# 50 "include/linux/spinlock.h" 2



# 1 "include/linux/kernel.h" 1
# 10 "include/linux/kernel.h"
# 1 "/usr/local/src/blackfin/toolchains/20070115/out-uclinux/lib/gcc/bfin-uclinux/4.1.1/include/stdarg.h" 1 3 4
# 43 "/usr/local/src/blackfin/toolchains/20070115/out-uclinux/lib/gcc/bfin-uclinux/4.1.1/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 105 "/usr/local/src/blackfin/toolchains/20070115/out-uclinux/lib/gcc/bfin-uclinux/4.1.1/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 11 "include/linux/kernel.h" 2






# 1 "include/asm/bug.h" 1
# 14 "include/asm/bug.h"
# 1 "include/asm-generic/bug.h" 1
# 15 "include/asm/bug.h" 2
# 18 "include/linux/kernel.h" 2

extern const char linux_banner[];
# 50 "include/linux/kernel.h"
extern int console_printk[];






struct completion;
struct pt_regs;
struct user;
# 98 "include/linux/kernel.h"
extern struct atomic_notifier_head panic_notifier_list;
extern long (*panic_blink)(long time);
 void panic(const char * fmt, ...)
 __attribute__ ((noreturn, format (printf, 1, 2)));
extern void oops_enter(void);
extern void oops_exit(void);
extern int oops_may_print(void);
 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)
 __attribute__ ((format (printf, 2, 0)));
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)
 __attribute__ ((format (printf, 3, 0)));
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)
 __attribute__ ((format (printf, 3, 0)));
extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
 __attribute__ ((format (printf, 2, 3)));

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

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 core_kernel_text(unsigned long addr);
extern int __kernel_text_address(unsigned long addr);
extern int kernel_text_address(unsigned long addr);
extern int session_of_pgrp(int pgrp);

extern void dump_thread(struct pt_regs *regs, struct user *dump);


 int vprintk(const char *fmt, va_list args)
 __attribute__ ((format (printf, 1, 0)));
 int printk(const char * fmt, ...)
 __attribute__ ((format (printf, 1, 2)));
# 158 "include/linux/kernel.h"
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_long(x - 1);
}

extern int printk_ratelimit(void);
extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);
extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
    unsigned int interval_msec);

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 panic_on_unrecovered_nmi;
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_SUSPEND_DISK,
} system_state;
# 216 "include/linux/kernel.h"
extern void dump_stack(void);






static inline __attribute__((always_inline)) int __attribute__ ((format (printf, 1, 2))) pr_debug(const char * fmt, ...)
{
 return 0;
}
# 330 "include/linux/kernel.h"
struct sysinfo {
 long uptime;
 unsigned long loads[3];
 unsigned long totalram;
 unsigned long freeram;
 unsigned long sharedram;
 unsigned long bufferram;
 unsigned long totalswap;
 unsigned long freeswap;
 unsigned short procs;
 unsigned short pad;
 unsigned long totalhigh;
 unsigned long freehigh;
 unsigned int mem_unit;
 char _f[20-2*sizeof(long)-sizeof(int)];
};
# 54 "include/linux/spinlock.h" 2
# 1 "include/linux/stringify.h" 1
# 55 "include/linux/spinlock.h" 2
# 1 "include/linux/bottom_half.h" 1
extern void local_bh_disable(void);
extern void __local_bh_enable(void);
extern void _local_bh_enable(void);
extern void local_bh_enable(void);
extern void local_bh_enable_ip(unsigned long ip);
# 56 "include/linux/spinlock.h" 2
# 79 "include/linux/spinlock.h"
# 1 "include/linux/spinlock_types.h" 1
# 12 "include/linux/spinlock_types.h"
# 1 "include/linux/lockdep.h" 1
# 248 "include/linux/lockdep.h"
static inline __attribute__((always_inline)) void lockdep_off(void)
{
}

static inline __attribute__((always_inline)) void lockdep_on(void)
{
}

static inline __attribute__((always_inline)) int lockdep_internal(void)
{
 return 0;
}
# 279 "include/linux/lockdep.h"
struct lock_class_key { };
# 13 "include/linux/spinlock_types.h" 2




# 1 "include/linux/spinlock_types_up.h" 1
# 29 "include/linux/spinlock_types_up.h"
typedef struct { } raw_spinlock_t;





typedef struct {




} raw_rwlock_t;
# 18 "include/linux/spinlock_types.h" 2


typedef struct {
 raw_spinlock_t raw_lock;
# 32 "include/linux/spinlock_types.h"
} spinlock_t;



typedef struct {
 raw_rwlock_t raw_lock;
# 48 "include/linux/spinlock_types.h"
} rwlock_t;
# 80 "include/linux/spinlock.h" 2

extern int __attribute__((section(".spinlock.text"))) generic__raw_read_trylock(raw_rwlock_t *lock);







# 1 "include/linux/spinlock_up.h" 1
# 90 "include/linux/spinlock.h" 2
# 135 "include/linux/spinlock.h"
# 1 "include/linux/spinlock_api_up.h" 1
# 136 "include/linux/spinlock.h" 2
# 274 "include/linux/spinlock.h"
# 1 "include/asm/atomic.h" 1
# 16 "include/asm/atomic.h"
typedef struct {
 int counter;
} atomic_t;





static __inline__ __attribute__((always_inline)) void atomic_add(int i, atomic_t * v)
{
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter += i;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static __inline__ __attribute__((always_inline)) void atomic_sub(int i, atomic_t * v)
{
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter -= i;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);

}

static inline __attribute__((always_inline)) int atomic_add_return(int i, atomic_t * v)
{
 int __temp = 0;
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter += i;
 __temp = v->counter;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);


 return __temp;
}


static inline __attribute__((always_inline)) int atomic_sub_return(int i, atomic_t * v)
{
 int __temp = 0;
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter -= i;
 __temp = v->counter;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);

 return __temp;
}

static __inline__ __attribute__((always_inline)) void atomic_inc(volatile atomic_t * v)
{
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter++;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}
# 93 "include/asm/atomic.h"
static __inline__ __attribute__((always_inline)) void atomic_dec(volatile atomic_t * v)
{
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter--;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static __inline__ __attribute__((always_inline)) void atomic_clear_mask(unsigned int mask, atomic_t * v)
{
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter &= ~mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static __inline__ __attribute__((always_inline)) void atomic_set_mask(unsigned int mask, atomic_t * v)
{
 long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 v->counter |= mask;
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}
# 142 "include/asm/atomic.h"
# 1 "include/asm-generic/atomic.h" 1
# 71 "include/asm-generic/atomic.h"
typedef atomic_t atomic_long_t;


static inline __attribute__((always_inline)) long atomic_long_read(atomic_long_t *l)
{
 atomic_t *v = (atomic_t *)l;

 return (long)((v)->counter);
}

static inline __attribute__((always_inline)) void atomic_long_set(atomic_long_t *l, long i)
{
 atomic_t *v = (atomic_t *)l;

 (((v)->counter) = i);
}

static inline __attribute__((always_inline)) void atomic_long_inc(atomic_long_t *l)
{
 atomic_t *v = (atomic_t *)l;

 atomic_inc(v);
}

static inline __attribute__((always_inline)) void atomic_long_dec(atomic_long_t *l)
{
 atomic_t *v = (atomic_t *)l;

 atomic_dec(v);
}

static inline __attribute__((always_inline)) void atomic_long_add(long i, atomic_long_t *l)
{
 atomic_t *v = (atomic_t *)l;

 atomic_add(i, v);
}

static inline __attribute__((always_inline)) void atomic_long_sub(long i, atomic_long_t *l)
{
 atomic_t *v = (atomic_t *)l;

 atomic_sub(i, v);
}
# 143 "include/asm/atomic.h" 2
# 275 "include/linux/spinlock.h" 2





extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
# 46 "include/linux/capability.h" 2
# 1 "include/asm/current.h" 1
# 13 "include/asm/current.h"
struct task_struct;

static inline __attribute__((always_inline)) struct task_struct *get_current(void) __attribute__ ((__const__));
static inline __attribute__((always_inline)) struct task_struct *get_current(void)
{
 return (current_thread_info()->task);
}
# 47 "include/linux/capability.h" 2
# 58 "include/linux/capability.h"
typedef __u32 kernel_cap_t;
# 295 "include/linux/capability.h"
extern kernel_cap_t cap_bset;
# 323 "include/linux/capability.h"
static inline __attribute__((always_inline)) kernel_cap_t cap_combine(kernel_cap_t a, kernel_cap_t b)
{
     kernel_cap_t dest;
     (dest) = (a) | (b);
     return dest;
}

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

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

static inline __attribute__((always_inline)) kernel_cap_t cap_invert(kernel_cap_t c)
{
     kernel_cap_t dest;
     (dest) = ~(c);
     return dest;
}
# 360 "include/linux/capability.h"
int capable(int cap);
int __capable(struct task_struct *t, int cap);
# 47 "include/linux/sched.h" 2
# 1 "include/linux/threads.h" 1
# 48 "include/linux/sched.h" 2


# 1 "include/linux/timex.h" 1
# 57 "include/linux/timex.h"
# 1 "include/linux/time.h" 1






# 1 "include/linux/seqlock.h" 1
# 32 "include/linux/seqlock.h"
typedef struct {
 unsigned sequence;
 spinlock_t lock;
} seqlock_t;
# 57 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) void write_seqlock(seqlock_t *sl)
{
 do { do { } while (0); (void)0; (void)(&sl->lock); } 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 { } while (0); (void)0; (void)(&sl->lock); } while (0);
}

static inline __attribute__((always_inline)) int write_tryseqlock(seqlock_t *sl)
{
 int ret = (({ do { do { } while (0); (void)0; (void)(&sl->lock); } while (0); 1; }));

 if (ret) {
  ++sl->sequence;
  __asm__ __volatile__("": : :"memory");
 }
 return ret;
}


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





static inline __attribute__((always_inline)) unsigned read_seqcount_begin(const seqcount_t *s)
{
 unsigned ret = s->sequence;
 __asm__ __volatile__("": : :"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++;
}
# 8 "include/linux/time.h" 2




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;
};
# 39 "include/linux/time.h"
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)) int timespec_compare(struct timespec *lhs, struct timespec *rhs)
{
 if (lhs->tv_sec < rhs->tv_sec)
  return -1;
 if (lhs->tv_sec > rhs->tv_sec)
  return 1;
 return lhs->tv_nsec - rhs->tv_nsec;
}

static inline __attribute__((always_inline)) int timeval_compare(struct timeval *lhs, struct timeval *rhs)
{
 if (lhs->tv_sec < rhs->tv_sec)
  return -1;
 if (lhs->tv_sec > rhs->tv_sec)
  return 1;
 return lhs->tv_usec - rhs->tv_usec;
}

extern unsigned long mktime(const unsigned int year, const unsigned int mon,
       const unsigned int day, const unsigned int hour,
       const unsigned int min, const unsigned int sec);

extern void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec);




static inline __attribute__((always_inline)) struct timespec timespec_sub(struct timespec lhs,
      struct timespec rhs)
{
 struct timespec ts_delta;
 set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
    lhs.tv_nsec - rhs.tv_nsec);
 return ts_delta;
}







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

void timekeeping_init(void);

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 long do_utimes(int dfd, char *filename, struct timeval *times);
struct itimerval;
extern int do_setitimer(int which, struct itimerval *value,
   struct itimerval *ovalue);
extern unsigned int alarm_setitimer(unsigned int seconds);
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);
extern int timekeeping_is_continuous(void);
# 129 "include/linux/time.h"
static inline __attribute__((always_inline)) s64 timespec_to_ns(const struct timespec *ts)
{
 return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;
}
# 141 "include/linux/time.h"
static inline __attribute__((always_inline)) s64 timeval_to_ns(const struct timeval *tv)
{
 return ((s64) tv->tv_sec * 1000000000L) +
  tv->tv_usec * 1000L;
}







extern struct timespec ns_to_timespec(const s64 nsec);







extern struct timeval ns_to_timeval(const s64 nsec);






static inline __attribute__((always_inline)) void timespec_add_ns(struct timespec *a, u64 ns)
{
 ns += a->tv_nsec;
 while(__builtin_expect(!!(ns >= 1000000000L), 0)) {
  ns -= 1000000000L;
  a->tv_sec++;
 }
 a->tv_nsec = ns;
}
# 195 "include/linux/time.h"
struct itimerspec {
 struct timespec it_interval;
 struct timespec it_value;
};

struct itimerval {
 struct timeval it_interval;
 struct timeval it_value;
};
# 58 "include/linux/timex.h" 2
# 100 "include/linux/timex.h"
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;
};
# 187 "include/linux/timex.h"
# 1 "include/asm/timex.h" 1
# 11 "include/asm/timex.h"
typedef unsigned long cycles_t;

static inline __attribute__((always_inline)) cycles_t get_cycles(void)
{
 return 0;
}
# 188 "include/linux/timex.h" 2






extern unsigned long tick_usec;
extern unsigned long tick_nsec;
extern int tickadj;




extern int time_status;
extern long time_maxerror;
extern long time_esterror;

extern long time_freq;

extern long time_adjust;

extern void ntp_clear(void);





static inline __attribute__((always_inline)) int ntp_synced(void)
{
 return !(time_status & 0x0040);
}
# 277 "include/linux/timex.h"
static inline __attribute__((always_inline)) void time_interpolator_reset(void)
{
}

static inline __attribute__((always_inline)) void time_interpolator_update(long delta_nsec)
{
}






extern u64 current_tick_length(void);

extern void second_overflow(void);
extern void update_ntp_one_tick(void);
extern int do_adjtimex(struct timex *);
# 51 "include/linux/sched.h" 2
# 1 "include/linux/jiffies.h" 1



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




# 1 "include/asm/div64.h" 1
# 1 "include/asm-generic/div64.h" 1
# 35 "include/asm-generic/div64.h"
extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
# 1 "include/asm/div64.h" 2
# 6 "include/linux/calc64.h" 2
# 20 "include/linux/calc64.h"
static inline __attribute__((always_inline)) unsigned long do_div_llr(const long long dividend,
           const long divisor, long *remainder)
{
 u64 result = dividend;

 *(remainder) = ({ uint32_t __base = (divisor); 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; });
 return (unsigned long) result;
}







static inline __attribute__((always_inline)) long div_long_long_rem_signed(const long long dividend,
         const long divisor, long *remainder)
{
 long res;

 if (__builtin_expect(!!(dividend < 0), 0)) {
  res = -do_div_llr((-dividend), divisor, remainder);
  *remainder = -(*remainder);
 } else
  res = do_div_llr((dividend), divisor, remainder);

 return res;
}
# 5 "include/linux/jiffies.h" 2
# 81 "include/linux/jiffies.h"
extern u64 __attribute__((section(".data"))) jiffies_64;
extern unsigned long volatile __attribute__((section(".data"))) jiffies;


u64 get_jiffies_64(void);
# 267 "include/linux/jiffies.h"
static inline __attribute__((always_inline)) unsigned int jiffies_to_msecs(const unsigned long j)
{

 return (1000L / 250) * j;





}

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

 return (1000000L / 250) * 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 + (1000L / 250) - 1) / (1000L / 250);





}

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 + (1000000L / 250) - 1) / (1000000L / 250);





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

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

}

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




 u64 nsec = (u64)jiffies * (( (((1000000UL * 1000) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((((1000000UL * 1000) % ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250))))) / 2) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))));
 value->tv_sec = do_div_llr((nsec), 1000000000L, &value->tv_nsec);
}
# 365 "include/linux/jiffies.h"
static __inline__ __attribute__((always_inline)) unsigned long
timeval_to_jiffies(const struct timeval *value)
{
 unsigned long sec = value->tv_sec;
 long usec = value->tv_usec;

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

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




 u64 nsec = (u64)jiffies * (( (((1000000UL * 1000) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((((1000000UL * 1000) % ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250))))) / 2) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))));
 long tv_usec;

 value->tv_sec = do_div_llr((nsec), 1000000000L, &tv_usec);
 tv_usec /= 1000L;
 value->tv_usec = tv_usec;
}




static inline __attribute__((always_inline)) clock_t jiffies_to_clock_t(long x)
{



 u64 tmp = (u64)x * (( (((1000000UL * 1000) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((((1000000UL * 1000) % ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250))))) / 2) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))));
 ({ 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)
{





 u64 jif;


 if (x >= ~0UL / 250 * 100)
  return ~0UL;


 jif = x * (u64) 250;
 ({ uint32_t __base = (100); uint32_t __rem; (void)(((typeof((jif)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((jif) >> 32) == 0), 1)) { __rem = (uint32_t)(jif) % __base; (jif) = (uint32_t)(jif) / __base; } else __rem = __div64_32(&(jif), __base); __rem; });
 return jif;

}

static inline __attribute__((always_inline)) u64 jiffies_64_to_clock_t(u64 x)
{
# 439 "include/linux/jiffies.h"
 x *= (( (((1000000UL * 1000) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((((1000000UL * 1000) % ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))) << (8)) + ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250))))) / 2) / ((( (((1000000) / (((1000000 + 250/2) / 250))) << (8)) + ((((1000000) % (((1000000 + 250/2) / 250))) << (8)) + (((1000000 + 250/2) / 250)) / 2) / (((1000000 + 250/2) / 250)))))));
 ({ 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; });
# 462 "include/linux/jiffies.h"
 return x;
}
# 52 "include/linux/sched.h" 2
# 1 "include/linux/rbtree.h" 1
# 100 "include/linux/rbtree.h"
struct rb_node
{
 unsigned long rb_parent_color;


 struct rb_node *rb_right;
 struct rb_node *rb_left;
} __attribute__((aligned(sizeof(long))));


struct rb_root
{
 struct rb_node *rb_node;
};
# 123 "include/linux/rbtree.h"
static inline __attribute__((always_inline)) void rb_set_parent(struct rb_node *rb, struct rb_node *p)
{
 rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
}
static inline __attribute__((always_inline)) void rb_set_color(struct rb_node *rb, int color)
{
 rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
}
# 139 "include/linux/rbtree.h"
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_color = (unsigned long )parent;
 node->rb_left = node->rb_right = ((void *)0);

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

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







# 1 "include/linux/string.h" 1
# 16 "include/linux/string.h"
extern char *strndup_user(const char *, long);




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






extern inline __attribute__((always_inline)) char *strcpy(char *dest, const char *src)
{
 char *xdest = dest;
 char temp = 0;

 __asm__ __volatile__
     ("1:\t%2 = B [%1++] (Z);\n\t"
      "B [%0++] = %2;\n\t"
      "CC = %2;\n\t"
        "if cc jump 1b (bp);\n"
 : "+&a" (dest), "+&a" (src), "=&d" (temp)
      ::"memory", "CC");
 return xdest;
}


extern inline __attribute__((always_inline)) char *strncpy(char *dest, const char *src, size_t n)
{
 char *xdest = dest;
 char temp = 0;

 if (n == 0)
  return xdest;

 __asm__ __volatile__
     ("1:\t%3 = B [%1++] (Z);\n\t"
      "B [%0++] = %3;\n\t"
      "CC = %3;\n\t"
      "if ! cc jump 2f;\n\t"
      "%2 += -1;\n\t"
      "CC = %2 == 0;\n\t"
      "if ! cc jump 1b (bp);\n"
        "2:\n"
 : "+&a" (dest), "+&a" (src), "+&da" (n), "=&d" (temp)
      ::"memory", "CC");
 return xdest;
}


extern inline __attribute__((always_inline)) int strcmp(const char *cs, const char *ct)
{
 char __res1, __res2;

 __asm__
       ("1:\t%2 = B[%0++] (Z);\n\t"
  "%3 = B[%1++] (Z);\n\t"
  "CC = %2 == %3;\n\t"
  "if ! cc jump 2f;\n\t"
  "CC = %2;\n\t"
  "if cc jump 1b (bp);\n\t"
  "jump.s 3f;\n"
  "2:\t%2 = %2 - %3;\n"
        "3:\n"
 : "+&a" (cs), "+&a" (ct), "=&d" (__res1), "=&d" (__res2)
      : : "CC");

 return __res1;
}


extern inline __attribute__((always_inline)) int strncmp(const char *cs, const char *ct, size_t count)
{
 char __res1, __res2;

 if (!count)
  return 0;
 __asm__
       ("1:\t%3 = B[%0++] (Z);\n\t"
  "%4 = B[%1++] (Z);\n\t"
  "CC = %3 == %4;\n\t"
  "if ! cc jump 3f;\n\t"
  "CC = %3;\n\t"
  "if ! cc jump 4f;\n\t"
  "%2 += -1;\n\t"
 "CC = %2 == 0;\n\t"
        "if ! cc jump 1b;\n"
  "2:\t%3 = 0;\n\t"
        "jump.s    4f;\n"
        "3:\t%3 = %3 - %4;\n"
        "4:"
 : "+&a" (cs), "+&a" (ct), "+&da" (count), "=&d" (__res1), "=&d" (__res2)
      : : "CC");
 return __res1;
}


extern void *memset(void *s, int c, size_t count);

extern void *memcpy(void *d, const void *s, size_t count);

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

extern void *memchr(const void *s, int c, size_t n);

extern void *memmove(void *dest, const void *src, size_t count);
# 22 "include/linux/string.h" 2
# 30 "include/linux/string.h"
size_t strlcpy(char *, const char *, size_t);


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


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


extern size_t strlcat(char *, const char *, __kernel_size_t);
# 48 "include/linux/string.h"
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 * strstrip(char *);

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


extern __kernel_size_t strlen(const char *);


extern __kernel_size_t strnlen(const char *,__kernel_size_t);


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 *);
# 92 "include/linux/string.h"
extern void * memscan(void *,int,__kernel_size_t);
# 101 "include/linux/string.h"
extern char *kstrdup(const char *s, gfp_t gfp);
extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
# 9 "include/linux/bitmap.h" 2
# 84 "include/linux/bitmap.h"
extern int __bitmap_empty(const unsigned long *bitmap, int bits);
extern int __bitmap_full(const unsigned long *bitmap, int bits);
extern int __bitmap_equal(const unsigned long *bitmap1,
                 const unsigned long *bitmap2, int bits);
extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
   int bits);
extern void __bitmap_shift_right(unsigned long *dst,
                        const unsigned long *src, int shift, int bits);
extern void __bitmap_shift_left(unsigned long *dst,
                        const unsigned long *src, int shift, int bits);
extern void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, int bits);
extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, int bits);
extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, int bits);
extern void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, int bits);
extern int __bitmap_intersects(const unsigned long *bitmap1,
   const unsigned long *bitmap2, int bits);
extern int __bitmap_subset(const unsigned long *bitmap1,
   const unsigned long *bitmap2, int bits);
extern int __bitmap_weight(const unsigned long *bitmap, int bits);

extern int bitmap_scnprintf(char *buf, unsigned int len,
   const unsigned long *src, int nbits);
extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
   unsigned long *dst, int nbits);
extern int bitmap_parse_user(const char *ubuf, unsigned int ulen,
   unsigned long *dst, int nbits);
extern int bitmap_scnlistprintf(char *buf, unsigned int len,
   const unsigned long *src, int nbits);
extern int bitmap_parselist(const char *buf, unsigned long *maskp,
   int nmaskbits);
extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
  const unsigned long *old, const unsigned long *new, int bits);
extern int bitmap_bitremap(int oldbit,
  const unsigned long *old, const unsigned long *new, int bits);
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)
{
 if (nbits <= 32)
  return hweight_long(*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
 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);
}

static inline __attribute__((always_inline)) int bitmap_parse(const char *buf, unsigned int buflen,
   unsigned long *maskp, int nmaskbits)
{
 return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
}
# 87 "include/linux/cpumask.h" 2

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);
}
# 270 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) int __cpumask_scnprintf(char *buf, int len,
     const cpumask_t *srcp, int nbits)
{
 return bitmap_scnprintf(buf, len, srcp->bits, nbits);
}



static inline __attribute__((always_inline)) int __cpumask_parse_user(const char *buf, int len,
     cpumask_t *dstp, int nbits)
{
 return bitmap_parse_user(buf, len, dstp->bits, nbits);
}



static inline __attribute__((always_inline)) int __cpulist_scnprintf(char *buf, int len,
     const cpumask_t *srcp, int nbits)
{
 return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
}


static inline __attribute__((always_inline)) int __cpulist_parse(const char *buf, cpumask_t *dstp, int nbits)
{
 return bitmap_parselist(buf, dstp->bits, nbits);
}



static inline __attribute__((always_inline)) int __cpu_remap(int oldbit,
  const cpumask_t *oldp, const cpumask_t *newp, int nbits)
{
 return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
}



static inline __attribute__((always_inline)) void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
  const cpumask_t *oldp, const cpumask_t *newp, int nbits)
{
 bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
}
# 380 "include/linux/cpumask.h"
extern cpumask_t cpu_possible_map;
extern cpumask_t cpu_online_map;
extern cpumask_t cpu_present_map;
# 55 "include/linux/sched.h" 2
# 1 "include/linux/errno.h" 1



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



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



# 1 "include/asm-generic/errno-base.h" 1
# 5 "include/asm-generic/errno.h" 2
# 5 "include/asm/errno.h" 2
# 5 "include/linux/errno.h" 2
# 56 "include/linux/sched.h" 2
# 1 "include/linux/nodemask.h" 1
# 86 "include/linux/nodemask.h"
# 1 "include/linux/numa.h" 1
# 87 "include/linux/nodemask.h" 2

typedef struct { unsigned long bits[((((1 << 0))+32 -1)/32)]; } nodemask_t;
extern nodemask_t _unused_nodemask_arg_;


static inline __attribute__((always_inline)) void __node_set(int node, volatile nodemask_t *dstp)
{
 set_bit(node, dstp->bits);
}


static inline __attribute__((always_inline)) void __node_clear(int node, volatile nodemask_t *dstp)
{
 clear_bit(node, dstp->bits);
}


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


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






static inline __attribute__((always_inline)) int __node_test_and_set(int node, nodemask_t *addr)
{
 return test_and_set_bit(node, addr->bits);
}



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



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



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



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



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



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



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



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


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


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


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



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



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





static inline __attribute__((always_inline)) int __first_node(const nodemask_t *srcp)
{
 return ({ int __x = ((1 << 0)); int __y = (find_next_bit((srcp->bits), ((1 << 0)), 0)); __x < __y ? __x: __y; });
}


static inline __attribute__((always_inline)) int __next_node(int n, const nodemask_t *srcp)
{
 return ({ int __x = ((1 << 0)); int __y = (find_next_bit(srcp->bits, (1 << 0), n+1)); __x < __y ? __x: __y; });
}
# 251 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) int __first_unset_node(const nodemask_t *maskp)
{
 return ({ int __x = ((1 << 0)); int __y = (find_next_zero_bit((maskp->bits), ((1 << 0)), 0)); __x < __y ? __x: __y; });

}
# 285 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) int __nodemask_scnprintf(char *buf, int len,
     const nodemask_t *srcp, int nbits)
{
 return bitmap_scnprintf(buf, len, srcp->bits, nbits);
}



static inline __attribute__((always_inline)) int __nodemask_parse_user(const char *buf, int len,
     nodemask_t *dstp, int nbits)
{
 return bitmap_parse_user(buf, len, dstp->bits, nbits);
}



static inline __attribute__((always_inline)) int __nodelist_scnprintf(char *buf, int len,
     const nodemask_t *srcp, int nbits)
{
 return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
}


static inline __attribute__((always_inline)) int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
{
 return bitmap_parselist(buf, dstp->bits, nbits);
}



static inline __attribute__((always_inline)) int __node_remap(int oldbit,
  const nodemask_t *oldp, const nodemask_t *newp, int nbits)
{
 return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
}



static inline __attribute__((always_inline)) void __nodes_remap(nodemask_t *dstp, const nodemask_t *srcp,
  const nodemask_t *oldp, const nodemask_t *newp, int nbits)
{
 bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
}
# 345 "include/linux/nodemask.h"
extern nodemask_t node_online_map;
extern nodemask_t node_possible_map;
# 57 "include/linux/sched.h" 2


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






# 1 "include/linux/wait.h" 1
# 22 "include/linux/wait.h"
# 1 "include/linux/list.h" 1






# 1 "include/linux/poison.h" 1
# 8 "include/linux/list.h" 2
# 1 "include/linux/prefetch.h" 1
# 14 "include/linux/prefetch.h"
# 1 "include/asm/processor.h" 1
# 10 "include/asm/processor.h"
# 1 "include/asm/segment.h" 1
# 11 "include/asm/processor.h" 2


static inline __attribute__((always_inline)) unsigned long rdusp(void)
{
 unsigned long usp;

 __asm__ __volatile__("%0 = usp;\n\t":"=da"(usp));
 return usp;
}

static inline __attribute__((always_inline)) void wrusp(unsigned long usp)
{
 __asm__ __volatile__("usp = %0;\n\t"::"da"(usp));
}




extern unsigned long memory_end;




struct thread_struct {
 unsigned long ksp;
 unsigned long usp;
 unsigned short seqstat;
 unsigned long esp0;
 unsigned long pc;
 void * debuggerinfo;
};
# 69 "include/asm/processor.h"
struct task_struct;


static inline __attribute__((always_inline)) void release_thread(struct task_struct *dead_task)
{
}



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




static inline __attribute__((always_inline)) void exit_thread(void)
{
}






unsigned long get_wchan(struct task_struct *p);
# 15 "include/linux/prefetch.h" 2
# 1 "include/asm/cache.h" 1
# 16 "include/linux/prefetch.h" 2
# 43 "include/linux/prefetch.h"
static inline __attribute__((always_inline)) void prefetch(const void *x) {;}



static inline __attribute__((always_inline)) void prefetchw(const void *x) {;}
# 58 "include/linux/prefetch.h"
static inline __attribute__((always_inline)) void prefetch_range(void *addr, size_t len)
{







}
# 9 "include/linux/list.h" 2
# 21 "include/linux/list.h"
struct list_head {
 struct list_head *next, *prev;
};






static inline __attribute__((always_inline)) void INIT_LIST_HEAD(struct list_head *list)
{
 list->next = list;
 list->prev = list;
}
# 43 "include/linux/list.h"
static inline __attribute__((always_inline)) void __list_add(struct list_head *new,
         struct list_head *prev,
         struct list_head *next)
{
 next->prev = new;
 new->next = next;
 new->prev = prev;
 prev->next = new;
}
# 67 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
{
 __list_add(new, head, head->next);
}
# 84 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add_tail(struct list_head *new, struct list_head *head)
{
 __list_add(new, head->prev, head);
}







static inline __attribute__((always_inline)) void __list_add_rcu(struct list_head * new,
  struct list_head * prev, struct list_head * next)
{
 new->next = next;
 new->prev = prev;
 __asm__ __volatile__("": : :"memory");
 next->prev = new;
 prev->next = new;
}
# 121 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add_rcu(struct list_head *new, struct list_head *head)
{
 __list_add_rcu(new, head, head->next);
}
# 142 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_add_tail_rcu(struct list_head *new,
     struct list_head *head)
{
 __list_add_rcu(new, head->prev, head);
}
# 155 "include/linux/list.h"
static inline __attribute__((always_inline)) void __list_del(struct list_head * prev, struct list_head * next)
{
 next->prev = prev;
 prev->next = next;
}
# 168 "include/linux/list.h"
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);
}
# 202 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_del_rcu(struct list_head *entry)
{
 __list_del(entry->prev, entry->next);
 entry->prev = ((void *) 0x00200200);
}







static inline __attribute__((always_inline)) void list_replace(struct list_head *old,
    struct list_head *new)
{
 new->next = old->next;
 new->next->prev = new;
 new->prev = old->prev;
 new->prev->next = new;
}

static inline __attribute__((always_inline)) void list_replace_init(struct list_head *old,
     struct list_head *new)
{
 list_replace(old, new);
 INIT_LIST_HEAD(old);
}
# 238 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_replace_rcu(struct list_head *old,
    struct list_head *new)
{
 new->next = old->next;
 new->prev = old->prev;
 __asm__ __volatile__("": : :"memory");
 new->next->prev = new;
 new->prev->next = new;
 old->prev = ((void *) 0x00200200);
}





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






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_is_last(const struct list_head *list,
    const struct list_head *head)
{
 return list->next == head;
}





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

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

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

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






static inline __attribute__((always_inline)) void list_splice(struct list_head *list, struct list_head *head)
{
 if (!list_empty(list))
  __list_splice(list, head);
}
# 353 "include/linux/list.h"
static inline __attribute__((always_inline)) void list_splice_init(struct list_head *list,
        struct list_head *head)
{
 if (!list_empty(list)) {
  __list_splice(list, head);
  INIT_LIST_HEAD(list);
 }
}
# 607 "include/linux/list.h"
struct hlist_head {
 struct hlist_node *first;
};

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




static inline __attribute__((always_inline)) void INIT_HLIST_NODE(struct hlist_node *h)
{
 h->next = ((void *)0);
 h->pprev = ((void *)0);
}

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);
}
# 669 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_del_rcu(struct hlist_node *n)
{
 __hlist_del(n);
 n->pprev = ((void *) 0x00200200);
}

static inline __attribute__((always_inline)) void hlist_del_init(struct hlist_node *n)
{
 if (!hlist_unhashed(n)) {
  __hlist_del(n);
  INIT_HLIST_NODE(n);
 }
}
# 690 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_replace_rcu(struct hlist_node *old,
     struct hlist_node *new)
{
 struct hlist_node *next = old->next;

 new->next = next;
 new->pprev = old->pprev;
 __asm__ __volatile__("": : :"memory");
 if (next)
  new->next->pprev = &new->next;
 *new->pprev = new;
 old->pprev = ((void *) 0x00200200);
}

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;
}
# 734 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_add_head_rcu(struct hlist_node *n,
     struct hlist_head *h)
{
 struct hlist_node *first = h->first;
 n->next = first;
 n->pprev = &h->first;
 __asm__ __volatile__("": : :"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;
}
# 785 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_add_before_rcu(struct hlist_node *n,
     struct hlist_node *next)
{
 n->pprev = next->pprev;
 n->next = next;
 __asm__ __volatile__("": : :"memory");
 next->pprev = &n->next;
 *(n->pprev) = n;
}
# 813 "include/linux/list.h"
static inline __attribute__((always_inline)) void hlist_add_after_rcu(struct hlist_node *prev,
           struct hlist_node *n)
{
 n->next = prev->next;
 n->pprev = &prev->next;
 __asm__ __volatile__("": : :"memory");
 prev->next = n;
 if (n->next)
  n->next->pprev = &n->next;
}
# 23 "include/linux/wait.h" 2





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

struct __wait_queue {
 unsigned int flags;

 void *private;
 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;

struct task_struct;
# 80 "include/linux/wait.h"
extern void init_waitqueue_head(wait_queue_head_t *q);
# 91 "include/linux/wait.h"
static inline __attribute__((always_inline)) void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
{
 q->flags = 0;
 q->private = 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->private = ((void *)0);
 q->func = func;
}

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

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




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

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

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




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






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

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





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

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

void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
# 429 "include/linux/wait.h"
static inline __attribute__((always_inline)) int wait_on_bit(void *word, int bit,
    int (*action)(void *), unsigned mode)
{
 if (!(__builtin_constant_p(bit) ? __constant_test_bit((bit),(word)) : __test_bit((bit),(word))))
  return 0;
 return out_of_line_wait_on_bit(word, bit, action, mode);
}
# 453 "include/linux/wait.h"
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);
}
# 8 "include/asm/semaphore.h" 2

# 1 "include/linux/rwsem.h" 1
# 19 "include/linux/rwsem.h"
struct rw_semaphore;


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



};
# 52 "include/linux/rwsem-spinlock.h"
extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
    struct lock_class_key *key);
# 62 "include/linux/rwsem-spinlock.h"
extern void __down_read(struct rw_semaphore *sem);
extern int __down_read_trylock(struct rw_semaphore *sem);
extern void __down_write(struct rw_semaphore *sem);
extern void __down_write_nested(struct rw_semaphore *sem, int subclass);
extern int __down_write_trylock(struct rw_semaphore *sem);
extern void __up_read(struct rw_semaphore *sem);
extern void __up_write(struct rw_semaphore *sem);
extern void __downgrade_write(struct rw_semaphore *sem);

static inline __attribute__((always_inline)) int rwsem_is_locked(struct rw_semaphore *sem)
{
 return (sem->activity != 0);
}
# 23 "include/linux/rwsem.h" 2







extern void down_read(struct rw_semaphore *sem);




extern int down_read_trylock(struct rw_semaphore *sem);




extern void down_write(struct rw_semaphore *sem);




extern int down_write_trylock(struct rw_semaphore *sem);




extern void up_read(struct rw_semaphore *sem);




extern void up_write(struct rw_semaphore *sem);




extern void downgrade_write(struct rw_semaphore *sem);
# 10 "include/asm/semaphore.h" 2
# 21 "include/asm/semaphore.h"
struct semaphore {
 atomic_t count;
 int sleepers;
 wait_queue_head_t wait;
};
# 40 "include/asm/semaphore.h"
static inline __attribute__((always_inline)) void sema_init(struct semaphore *sem, int val)
{
 *sem = (struct semaphore){ .count = { (val) }, .sleepers = 0, .wait = { .lock = (spinlock_t) { .raw_lock = { }, }, .task_list = { &((*sem).wait).task_list, &((*sem).wait).task_list } } };
}

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

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

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

extern spinlock_t semaphore_wake_lock;






static inline __attribute__((always_inline)) void down(struct semaphore *sem)
{
 do { do { } while (0); } while (0);
 if (atomic_sub_return(1,(&sem->count)) < 0)
  __down(sem);
}

static inline __attribute__((always_inline)) int down_interruptible(struct semaphore *sem)
{
 int ret = 0;

 do { do { } while (0); } while (0);
 if (atomic_sub_return(1,(&sem->count)) < 0)
  ret = __down_interruptible(sem);
 return (ret);
}

static inline __attribute__((always_inline)) int down_trylock(struct semaphore *sem)
{
 int ret = 0;

 if (atomic_sub_return(1,(&sem->count)) < 0)
  ret = __down_trylock(sem);
 return ret;
}







static inline __attribute__((always_inline)) void up(struct semaphore *sem)
{
 if (atomic_add_return(1,(&sem->count)) <= 0)
  __up(sem);
}
# 60 "include/linux/sched.h" 2


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





struct sram_list_struct {
 struct sram_list_struct *next;
 void *addr;
 size_t length;
};

typedef struct {
 struct vm_list_struct *vmlist;
 unsigned long end_brk;
 unsigned long stack_start;



 void *l1_stack_save;

 struct sram_list_struct *sram_list;


 unsigned long exec_fdpic_loadmap;
 unsigned long interp_fdpic_loadmap;


} mm_context_t;
# 63 "include/linux/sched.h" 2
# 1 "include/asm/cputime.h" 1



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






typedef unsigned long cputime_t;
# 23 "include/asm-generic/cputime.h"
typedef u64 cputime64_t;
# 5 "include/asm/cputime.h" 2
# 64 "include/linux/sched.h" 2

# 1 "include/linux/smp.h" 1
# 10 "include/linux/smp.h"
extern void cpu_idle(void);
# 87 "include/linux/smp.h"
static inline __attribute__((always_inline)) int up_smp_call_function(void)
{
 return 0;
}
# 99 "include/linux/smp.h"
static inline __attribute__((always_inline)) void smp_send_reschedule(int cpu) { }
# 131 "include/linux/smp.h"
void smp_setup_processor_id(void);
# 66 "include/linux/sched.h" 2
# 1 "include/linux/sem.h" 1



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


# 1 "include/asm/ipcbuf.h" 1
# 16 "include/asm/ipcbuf.h"
struct ipc64_perm {
 __kernel_key_t key;
 __kernel_uid32_t uid;
 __kernel_gid32_t gid;
 __kernel_uid32_t cuid;
 __kernel_gid32_t cgid;
 __kernel_mode_t mode;
 unsigned short __pad1;
 unsigned short seq;
 unsigned short __pad2;
 unsigned long __unused1;
 unsigned long __unused2;
};
# 22 "include/linux/ipc.h" 2
# 54 "include/linux/ipc.h"
# 1 "include/linux/kref.h" 1
# 23 "include/linux/kref.h"
struct kref {
 atomic_t refcount;
};

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




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 ipc_ids;
struct ipc_namespace {
 struct kref kref;
 struct ipc_ids *ids[3];

 int sem_ctls[4];
 int used_sems;

 int msg_ctlmax;
 int msg_ctlmnb;
 int msg_ctlmni;

 size_t shm_ctlmax;
 size_t shm_ctlall;
 int shm_ctlmni;
 int shm_tot;
};

extern struct ipc_namespace init_ipc_ns;
# 104 "include/linux/ipc.h"
static inline __attribute__((always_inline)) int copy_ipcs(unsigned long flags, struct task_struct *tsk)
{
 return 0;
}


static inline __attribute__((always_inline)) struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
{




 return ns;
}

static inline __attribute__((always_inline)) void put_ipc_ns(struct ipc_namespace *ns)
{



}
# 5 "include/linux/sem.h" 2
# 23 "include/linux/sem.h"
struct semid_ds {
 struct ipc_perm sem_perm;
 __kernel_time_t sem_otime;
 __kernel_time_t sem_ctime;
 struct sem *sem_base;
 struct sem_queue *sem_pending;
 struct sem_queue **sem_pending_last;
 struct sem_undo *undo;
 unsigned short sem_nsems;
};


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


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


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

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


struct sem {
 int semval;
 int sempid;
};


struct sem_array {
 struct kern_ipc_perm sem_perm;
 int sem_id;
 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;
}
# 67 "include/linux/sched.h" 2
# 1 "include/linux/signal.h" 1



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






struct siginfo;
# 17 "include/asm/signal.h"
typedef unsigned long old_sigset_t;

typedef struct {
 unsigned long sig[(64 / 32)];
} sigset_t;
# 107 "include/asm/signal.h"
# 1 "include/asm-generic/signal.h" 1
# 17 "include/asm-generic/signal.h"
typedef void __signalfn_t(int);
typedef __signalfn_t *__sighandler_t;

typedef void __restorefn_t(void);
typedef __restorefn_t *__sigrestore_t;
# 108 "include/asm/signal.h" 2


struct old_sigaction {
 __sighandler_t sa_handler;
 old_sigset_t sa_mask;
 unsigned long sa_flags;
 void (*sa_restorer) (void);
};

struct sigaction {
 __sighandler_t sa_handler;
 unsigned long sa_flags;
 void (*sa_restorer) (void);
 sigset_t sa_mask;
};

struct k_sigaction {
 struct sigaction sa;
};
# 145 "include/asm/signal.h"
typedef struct sigaltstack {
 void *ss_sp;
 int ss_flags;
 size_t ss_size;
} stack_t;



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




struct sigcontext {
 unsigned long sc_mask;
 unsigned long sc_usp;
 unsigned long sc_r0;
 unsigned long sc_r1;
 unsigned long sc_r2;
 unsigned long sc_r3;
 unsigned long sc_r4;
 unsigned long sc_p0;
 unsigned long sc_p1;
 unsigned long sc_p2;
 unsigned long sc_p3;
 unsigned long sc_i0;
 unsigned long sc_i1;
 unsigned long sc_i2;
 unsigned long sc_i3;
 unsigned long sc_m0;
 unsigned long sc_m1;
 unsigned long sc_m2;
 unsigned long sc_m3;
 unsigned long sc_l0;
 unsigned long sc_l1;
 unsigned long sc_l2;
 unsigned long sc_l3;
 unsigned long sc_b0;
 unsigned long sc_b1;
 unsigned long sc_b2;
 unsigned long sc_b3;
 unsigned long sc_a0x;
 unsigned long sc_a0w;
 unsigned long sc_a1x;
 unsigned long sc_a1w;
 unsigned long sc_astat;
 unsigned long sc_rets;
 unsigned long sc_lc0;
 unsigned long sc_lc1;
 unsigned long sc_lt0;
 unsigned long sc_lt1;
 unsigned long sc_lb0;
 unsigned long sc_lb1;
 unsigned long sc_seqstat;
 unsigned long sc_pc;
 unsigned long sc_retx;
};
# 154 "include/asm/signal.h" 2
# 5 "include/linux/signal.h" 2
# 1 "include/asm/siginfo.h" 1




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






typedef union sigval {
 int sival_int;
 void *sival_ptr;
} sigval_t;
# 40 "include/asm-generic/siginfo.h"
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;
# 251 "include/asm-generic/siginfo.h"
typedef struct sigevent {
 sigval_t sigev_value;
 int sigev_signo;
 int sigev_notify;
 union {
  int _pad[((64 - (sizeof(int) * 2 + sizeof(sigval_t))) / sizeof(int))];
   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);
# 6 "include/asm/siginfo.h" 2
# 6 "include/linux/signal.h" 2
# 15 "include/linux/signal.h"
struct sigqueue {
 struct list_head list;
 int flags;
 siginfo_t info;
 struct user_struct *user;
};




struct sigpending {
 struct list_head list;
 sigset_t signal;
};
# 39 "include/linux/signal.h"
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 __ffs(~(~word));
}



static inline __attribute__((always_inline)) int sigisemptyset(sigset_t *set)
{
 extern void _NSIG_WORDS_is_unsupported_size(void);
 switch ((64 / 32)) {
 case 4:
  return (set->sig[3] | set->sig[2] |
   set->sig[1] | set->sig[0]) == 0;
 case 2:
  return (set->sig[1] | set->sig[0]) == 0;
 case 1:
  return set->sig[0] == 0;
 default:
  _NSIG_WORDS_is_unsupported_size();
  return 0;
 }
}
# 120 "include/linux/signal.h"
static inline __attribute__((always_inline)) void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 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(); } }
# 150 "include/linux/signal.h"
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);
 INIT_LIST_HEAD(&sig->list);
}

extern void flush_sigqueue(struct sigpending *queue);


static inline __attribute__((always_inline)) int valid_signal(unsigned long sig)
{
 return sig <= 64 ? 1 : 0;
}

extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
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);
# 68 "include/linux/sched.h" 2
# 1 "include/linux/securebits.h" 1





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



struct dentry;
struct vfsmount;

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







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

# 1 "include/linux/completion.h" 1
# 13 "include/linux/completion.h"
struct completion {
 unsigned int done;
 wait_queue_head_t wait;
};
# 39 "include/linux/completion.h"
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 *);
# 72 "include/linux/sched.h" 2
# 1 "include/linux/pid.h" 1



# 1 "include/linux/rcupdate.h" 1
# 38 "include/linux/rcupdate.h"
# 1 "include/linux/cache.h" 1
# 39 "include/linux/rcupdate.h" 2


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




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

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



# 1 "include/linux/mmzone.h" 1
# 13 "include/linux/mmzone.h"
# 1 "include/linux/init.h" 1
# 63 "include/linux/init.h"
typedef int (*initcall_t)(void);
typedef void (*exitcall_t)(void);

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


extern char saved_command_line[];
extern unsigned int reset_devices;


extern void setup_arch(char **);
# 132 "include/linux/init.h"
struct obs_kernel_param {
 const char *str;
 int (*setup_func)(char *);
 int early;
};
# 167 "include/linux/init.h"
void __attribute__ ((__section__ (".init.text"))) parse_early_param(void);
# 14 "include/linux/mmzone.h" 2
# 27 "include/linux/mmzone.h"
struct free_area {
 struct list_head free_list;
 unsigned long nr_free;
};

struct pglist_data;
# 49 "include/linux/mmzone.h"
enum zone_stat_item {
 NR_ANON_PAGES,
 NR_FILE_MAPPED,

 NR_FILE_PAGES,
 NR_SLAB_RECLAIMABLE,
 NR_SLAB_UNRECLAIMABLE,
 NR_PAGETABLE,
 NR_FILE_DIRTY,
 NR_WRITEBACK,
 NR_UNSTABLE_NFS,
 NR_BOUNCE,
 NR_VMSCAN_WRITE,
# 70 "include/linux/mmzone.h"
 NR_VM_ZONE_STAT_ITEMS };

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

struct per_cpu_pageset {
 struct per_cpu_pages pcp[2];




} ;







enum zone_type {
# 113 "include/linux/mmzone.h"
 ZONE_DMA,
# 127 "include/linux/mmzone.h"
 ZONE_NORMAL,
# 139 "include/linux/mmzone.h"
 MAX_NR_ZONES
};
# 156 "include/linux/mmzone.h"
struct zone {

 unsigned long free_pages;
 unsigned long pages_min, pages_low, pages_high;
# 168 "include/linux/mmzone.h"
 unsigned long lowmem_reserve[MAX_NR_ZONES];
# 179 "include/linux/mmzone.h"
 struct per_cpu_pageset pageset[1];




 spinlock_t lock;




 struct free_area free_area[14];







 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;


 atomic_t reclaim_in_progress;


 atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
# 226 "include/linux/mmzone.h"
 int prev_priority;



# 256 "include/linux/mmzone.h"
 wait_queue_head_t * wait_table;
 unsigned long wait_table_hash_nr_entries;
 unsigned long wait_table_bits;




 struct pglist_data *zone_pgdat;

 unsigned long zone_start_pfn;
# 277 "include/linux/mmzone.h"
 unsigned long spanned_pages;
 unsigned long present_pages;




 char *name;
} ;
# 304 "include/linux/mmzone.h"
struct zonelist {
 struct zone *zones[(1 << 0) * MAX_NR_ZONES + 1];
};
# 318 "include/linux/mmzone.h"
extern struct page *mem_map;
# 332 "include/linux/mmzone.h"
struct bootmem_data;
typedef struct pglist_data {
 struct zone node_zones[MAX_NR_ZONES];
 struct zonelist node_zonelists[MAX_NR_ZONES];
 int nr_zones;

 struct page *node_mem_map;

 struct bootmem_data *bdata;
# 351 "include/linux/mmzone.h"
 unsigned long node_start_pfn;
 unsigned long node_present_pages;
 unsigned long node_spanned_pages;

 int node_id;
 wait_queue_head_t kswapd_wait;
 struct task_struct *kswapd;
 int kswapd_max_order;
} pg_data_t;
# 370 "include/linux/mmzone.h"
# 1 "include/linux/memory_hotplug.h" 1



# 1 "include/linux/mmzone.h" 1
# 5 "include/linux/memory_hotplug.h" 2


# 1 "include/linux/notifier.h" 1
# 13 "include/linux/notifier.h"
# 1 "include/linux/mutex.h" 1
# 47 "include/linux/mutex.h"
struct mutex {

 atomic_t count;
 spinlock_t wait_lock;
 struct list_head wait_list;
# 60 "include/linux/mutex.h"
};





struct mutex_waiter {
 struct list_head list;
 struct task_struct *task;




};
# 105 "include/linux/mutex.h"
extern void __mutex_init(struct mutex *lock, const char *name,
    struct lock_class_key *key);







static inline __attribute__((always_inline)) int mutex_is_locked(struct mutex *lock)
{
 return ((&lock->count)->counter) != 1;
}





extern void mutex_lock(struct mutex *lock);
extern int mutex_lock_interruptible(struct mutex *lock);
# 136 "include/linux/mutex.h"
extern int mutex_trylock(struct mutex *lock);
extern void mutex_unlock(struct mutex *lock);
# 14 "include/linux/notifier.h" 2

# 1 "include/linux/srcu.h" 1
# 30 "include/linux/srcu.h"
struct srcu_struct_array {
 int c[2];
};

struct srcu_struct {
 int completed;
 struct srcu_struct_array *per_cpu_ref;
 struct mutex mutex;
};







int init_srcu_struct(struct srcu_struct *sp);
void cleanup_srcu_struct(struct srcu_struct *sp);
int srcu_read_lock(struct srcu_struct *sp) ;
void srcu_read_unlock(struct srcu_struct *sp, int idx) ;
void synchronize_srcu(struct srcu_struct *sp);
long srcu_batches_completed(struct srcu_struct *sp);
# 16 "include/linux/notifier.h" 2
# 50 "include/linux/notifier.h"
struct notifier_block {
 int (*notifier_call)(struct notifier_block *, unsigned long, void *);
 struct notifier_block *next;
 int priority;
};

struct atomic_notifier_head {
 spinlock_t lock;
 struct notifier_block *head;
};

struct blocking_notifier_head {
 struct rw_semaphore rwsem;
 struct notifier_block *head;
};

struct raw_notifier_head {
 struct notifier_block *head;
};

struct srcu_notifier_head {
 struct mutex mutex;
 struct srcu_struct srcu;
 struct notifier_block *head;
};
# 89 "include/linux/notifier.h"
extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
# 115 "include/linux/notifier.h"
extern int atomic_notifier_chain_register(struct atomic_notifier_head *,
  struct notifier_block *);
extern int blocking_notifier_chain_register(struct blocking_notifier_head *,
  struct notifier_block *);
extern int raw_notifier_chain_register(struct raw_notifier_head *,
  struct notifier_block *);
extern int srcu_notifier_chain_register(struct srcu_notifier_head *,
  struct notifier_block *);

extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *,
  struct notifier_block *);
extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *,
  struct notifier_block *);
extern int raw_notifier_chain_unregister(struct raw_notifier_head *,
  struct notifier_block *);
extern int srcu_notifier_chain_unregister(struct srcu_notifier_head *,
  struct notifier_block *);

extern int atomic_notifier_call_chain(struct atomic_notifier_head *,
  unsigned long val, void *v);
extern int blocking_notifier_call_chain(struct blocking_notifier_head *,
  unsigned long val, void *v);
extern int raw_notifier_call_chain(struct raw_notifier_head *,
  unsigned long val, void *v);
extern int srcu_notifier_call_chain(struct srcu_notifier_head *,
  unsigned long val, void *v);
# 8 "include/linux/memory_hotplug.h" 2

struct page;
struct zone;
struct pglist_data;
# 140 "include/linux/memory_hotplug.h"
static inline __attribute__((always_inline)) void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
static inline __attribute__((always_inline)) void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
static inline __attribute__((always_inline)) void pgdat_resize_init(struct pglist_data *pgdat) {}

static inline __attribute__((always_inline)) unsigned zone_span_seqbegin(struct zone *zone)
{
 return 0;
}
static inline __attribute__((always_inline)) int zone_span_seqretry(struct zone *zone, unsigned iv)
{
 return 0;
}
static inline __attribute__((always_inline)) void zone_span_writelock(struct zone *zone) {}
static inline __attribute__((always_inline)) void zone_span_writeunlock(struct zone *zone) {}
static inline __attribute__((always_inline)) void zone_seqlock_init(struct zone *zone) {}

static inline __attribute__((always_inline)) int mhp_notimplemented(const char *func)
{
 printk("<4>" "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n", func);
 dump_stack();
 return -38;
}


static inline __attribute__((always_inline)) int __remove_pages(struct zone *zone, unsigned long start_pfn,
 unsigned long nr_pages)
{
 printk("<4>" "%s() called, not yet supported\n", (__func__));
 dump_stack();
 return -38;
}

extern int add_memory(int nid, u64 start, u64 size);
extern int arch_add_memory(int nid, u64 start, u64 size);
extern int remove_memory(u64 start, u64 size);
extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
        int nr_pages);
# 371 "include/linux/mmzone.h" 2

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 classzone_idx, int alloc_flags);

extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
         unsigned long size);




static inline __attribute__((always_inline)) void memory_present(int nid, unsigned long start, unsigned long end) {}
# 399 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) int populated_zone(struct zone *zone)
{
 return (!!zone->present_pages);
}

static inline __attribute__((always_inline)) int is_highmem_idx(enum zone_type idx)
{



 return 0;

}

static inline __attribute__((always_inline)) int is_normal_idx(enum zone_type idx)
{
 return (idx == ZONE_NORMAL);
}







static inline __attribute__((always_inline)) int is_highmem(struct zone *zone)
{



 return 0;

}

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

static inline __attribute__((always_inline)) int is_dma32(struct zone *zone)
{



 return 0;

}

static inline __attribute__((always_inline)) int is_dma(struct zone *zone)
{
 return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
}


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[MAX_NR_ZONES-1];
int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
   struct file *, void *, size_t *, loff_t *);
int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
   struct file *, void *, size_t *, loff_t *);

# 1 "include/linux/topology.h" 1
# 34 "include/linux/topology.h"
# 1 "include/asm/topology.h" 1



# 1 "include/asm-generic/topology.h" 1
# 5 "include/asm/topology.h" 2
# 35 "include/linux/topology.h" 2
# 468 "include/linux/mmzone.h" 2







extern struct pglist_data contig_page_data;
# 486 "include/linux/mmzone.h"
extern struct pglist_data *first_online_pgdat(void);
extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
extern struct zone *next_zone(struct zone *zone);
# 685 "include/linux/mmzone.h"
void memory_present(int nid, unsigned long start, unsigned long end);
unsigned long __attribute__ ((__section__ (".init.text"))) node_memmap_size_bytes(int, unsigned long, unsigned long);
# 5 "include/linux/gfp.h" 2



struct vm_area_struct;
# 86 "include/linux/gfp.h"
static inline __attribute__((always_inline)) enum zone_type gfp_zone(gfp_t flags)
{
 if (flags & (( gfp_t)0x01u))
  return ZONE_DMA;
# 98 "include/linux/gfp.h"
 return ZONE_NORMAL;
}
# 117 "include/linux/gfp.h"
static inline __attribute__((always_inline)) void arch_free_page(struct page *page, int order) { }


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

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


 if (nid < 0)
  nid = ((0));

 return __alloc_pages(gfp_mask, order,
  (&contig_page_data)->node_zonelists + gfp_zone(gfp_mask));
}
# 157 "include/linux/gfp.h"
extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
extern unsigned long get_zeroed_page(gfp_t 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);



static inline __attribute__((always_inline)) void drain_node_pages(int node) { };
# 15 "include/linux/slab.h" 2
# 58 "include/linux/slab.h"
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 void kmem_cache_destroy(kmem_cache_t *);
extern int kmem_cache_shrink(kmem_cache_t *);
extern void *kmem_cache_alloc(kmem_cache_t *, gfp_t);
extern void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
extern void kmem_cache_free(kmem_cache_t *, void *);
extern unsigned int kmem_cache_size(kmem_cache_t *);
extern const char *kmem_cache_name(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, gfp_t);
# 126 "include/linux/slab.h"
static inline __attribute__((always_inline)) void *kmalloc(size_t size, gfp_t flags)
{
 if (__builtin_constant_p(size)) {
  int i = 0;





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

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

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

 if (size <= 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++;

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


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

 if (size <= 2097152) goto found; else i++;
 if (size <= 4194304) goto found; else i++;
 if (size <= 8388608) goto found; else i++;
 if (size <= 16777216) goto found; else i++;
 if (size <= 33554432) goto found; else i++;
# 136 "include/linux/slab.h" 2

  {
   extern void __you_cannot_kmalloc_that_much(void);
   __you_cannot_kmalloc_that_much();
  }
found:
  return kmem_cache_alloc((flags & (( gfp_t)0x01u)) ?
   malloc_sizes[i].cs_dmacachep :
   malloc_sizes[i].cs_cachep, flags);
 }
 return __kmalloc(size, flags);
}
# 166 "include/linux/slab.h"
extern void *__kzalloc(size_t, gfp_t);






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





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

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

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

 if (size <= 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++;

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


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

 if (size <= 2097152) goto found; else i++;
 if (size <= 4194304) goto found; else i++;
 if (size <= 8388608) goto found; else i++;
 if (size <= 16777216) goto found; else i++;
 if (size <= 33554432) goto found; else i++;
# 183 "include/linux/slab.h" 2

  {
   extern void __you_cannot_kzalloc_that_much(void);
   __you_cannot_kzalloc_that_much();
  }
found:
  return kmem_cache_zalloc((flags & (( gfp_t)0x01u)) ?
   malloc_sizes[i].cs_dmacachep :
   malloc_sizes[i].cs_cachep, flags);
 }
 return __kzalloc(size, flags);
}







static inline __attribute__((always_inline)) void *kcalloc(size_t n, size_t size, gfp_t flags)
{
 if (n != 0 && size > (~0UL) / n)
  return ((void *)0);
 return kzalloc(n * size, flags);
}

extern void kfree(const void *);
extern unsigned int ksize(const void *);
extern int slab_is_available(void);
# 240 "include/linux/slab.h"
static inline __attribute__((always_inline)) void *kmem_cache_alloc_node(kmem_cache_t *cachep, gfp_t flags, int node)
{
 return kmem_cache_alloc(cachep, flags);
}
static inline __attribute__((always_inline)) void *kmalloc_node(size_t size, gfp_t flags, int node)
{
 return kmalloc(size, flags);
}


extern int kmem_cache_reap(int);
extern int kmem_ptr_validate(kmem_cache_t *cachep, void *ptr);
# 289 "include/linux/slab.h"
extern kmem_cache_t *vm_area_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 *sighand_cachep;
extern kmem_cache_t *bio_cachep;
# 6 "include/linux/percpu.h" 2




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



# 1 "include/asm-generic/percpu.h" 1
# 5 "include/asm/percpu.h" 2
# 11 "include/linux/percpu.h" 2
# 57 "include/linux/percpu.h"
static inline __attribute__((always_inline)) void percpu_depopulate(void *__pdata, int cpu)
{
}

static inline __attribute__((always_inline)) void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask)
{
}

static inline __attribute__((always_inline)) void *percpu_populate(void *__pdata, size_t size, gfp_t gfp,
        int cpu)
{
 return ({ (void)(cpu); (__pdata); });
}

static inline __attribute__((always_inline)) int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
      cpumask_t *mask)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((always_inline)) void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask)
{
 return kzalloc(size, gfp);
}

static inline __attribute__((always_inline)) void percpu_free(void *__pdata)
{
 kfree(__pdata);
}
# 42 "include/linux/rcupdate.h" 2
# 50 "include/linux/rcupdate.h"
struct rcu_head {
 struct rcu_head *next;
 void (*func)(struct rcu_head *head);
};
# 64 "include/linux/rcupdate.h"
struct rcu_ctrlblk {
 long cur;
 long completed;
 int next_pending;

 int signaled;

 spinlock_t lock ;
 cpumask_t cpumask;

} ;


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;
 long qlen;
 struct rcu_head *curlist;
 struct rcu_head **curtail;
 struct rcu_head *donelist;
 struct rcu_head **donetail;
 long blimit;
 int cpu;
 struct rcu_head barrier;
};

extern __typeof__(struct rcu_data) per_cpu__rcu_data;
extern __typeof__(struct rcu_data) per_cpu__rcu_bh_data;







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

extern int rcu_pending(int cpu);
extern int rcu_needs_cpu(int cpu);
# 272 "include/linux/rcupdate.h"
extern void rcu_init(void);
extern void rcu_check_callbacks(int cpu, int user);
extern void rcu_restart_cpu(int cpu);
extern long rcu_batches_completed(void);
extern long rcu_batches_completed_bh(void);


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_rcu(void);
void synchronize_idle(void);
extern void rcu_barrier(void);
# 5 "include/linux/pid.h" 2

enum pid_type
{
 PIDTYPE_PID,
 PIDTYPE_PGID,
 PIDTYPE_SID,
 PIDTYPE_MAX
};
# 42 "include/linux/pid.h"
struct pid
{
 atomic_t count;

 int nr;
 struct hlist_node pid_chain;

 struct hlist_head tasks[PIDTYPE_MAX];
 struct rcu_head rcu;
};

struct pid_link
{
 struct hlist_node node;
 struct pid *pid;
};

static inline __attribute__((always_inline)) struct pid *get_pid(struct pid *pid)
{
 if (pid)
  atomic_inc(&pid->count);
 return pid;
}

extern void put_pid(struct pid *pid);
extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);


extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);





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 void transfer_pid(struct task_struct *old, struct task_struct *new, enum pid_type);






extern struct pid *find_pid(int nr);




extern struct pid *find_get_pid(int nr);
extern struct pid *find_ge_pid(int nr);

extern struct pid *alloc_pid(void);
extern void free_pid(struct pid *pid);

static inline __attribute__((always_inline)) pid_t pid_nr(struct pid *pid)
{
 pid_t nr = 0;
 if (pid)
  nr = pid->nr;
 return nr;
}
# 73 "include/linux/sched.h" 2


# 1 "include/linux/seccomp.h" 1
# 28 "include/linux/seccomp.h"
typedef struct { } seccomp_t;



static inline __attribute__((always_inline)) int has_secure_computing(struct thread_info *ti)
{
 return 0;
}
# 76 "include/linux/sched.h" 2

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



# 1 "include/linux/sched.h" 1
# 5 "include/linux/futex.h" 2
# 33 "include/linux/futex.h"
struct robust_list {
 struct robust_list *next;
};
# 45 "include/linux/futex.h"
struct robust_list_head {



 struct robust_list list;







 long futex_offset;
# 69 "include/linux/futex.h"
 struct robust_list *list_op_pending;
};
# 96 "include/linux/futex.h"
long do_futex(u32 *uaddr, int op, u32 val, unsigned long timeout,
       u32 *uaddr2, u32 val2, u32 val3);

extern int
handle_futex_death(u32 *uaddr, struct task_struct *curr, int pi);


extern void exit_robust_list(struct task_struct *curr);
extern void exit_pi_state_list(struct task_struct *curr);
# 78 "include/linux/sched.h" 2
# 1 "include/linux/rtmutex.h" 1
# 16 "include/linux/rtmutex.h"
# 1 "include/linux/plist.h" 1
# 80 "include/linux/plist.h"
struct plist_head {
 struct list_head prio_list;
 struct list_head node_list;



};

struct plist_node {
 int prio;
 struct plist_head plist;
};
# 128 "include/linux/plist.h"
static inline __attribute__((always_inline)) void
plist_head_init(struct plist_head *head, spinlock_t *lock)
{
 INIT_LIST_HEAD(&head->prio_list);
 INIT_LIST_HEAD(&head->node_list);



}







static inline __attribute__((always_inline)) void plist_node_init(struct plist_node *node, int prio)
{
 node->prio = prio;
 plist_head_init(&node->plist, ((void *)0));
}

extern void plist_add(struct plist_node *node, struct plist_head *head);
extern void plist_del(struct plist_node *node, struct plist_head *head);
# 200 "include/linux/plist.h"
static inline __attribute__((always_inline)) int plist_head_empty(const struct plist_head *head)
{
 return list_empty(&head->node_list);
}






static inline __attribute__((always_inline)) int plist_node_empty(const struct plist_node *node)
{
 return plist_head_empty(&node->plist);
}
# 242 "include/linux/plist.h"
static inline __attribute__((always_inline)) struct plist_node* plist_first(const struct plist_head *head)
{
 return ({ const typeof( ((struct plist_node *)0)->plist.node_list ) *__mptr = (head->node_list.next); (struct plist_node *)( (char *)__mptr - __builtin_offsetof(struct plist_node,plist.node_list) );});

}
# 17 "include/linux/rtmutex.h" 2
# 26 "include/linux/rtmutex.h"
struct rt_mutex {
 spinlock_t wait_lock;
 struct plist_head wait_list;
 struct task_struct *owner;






};

struct rt_mutex_waiter;
struct hrtimer_sleeper;






 static inline __attribute__((always_inline)) int rt_mutex_debug_check_no_locks_freed(const void *from,
             unsigned long len)
 {
 return 0;
 }
# 80 "include/linux/rtmutex.h"
static inline __attribute__((always_inline)) int rt_mutex_is_locked(struct rt_mutex *lock)
{
 return lock->owner != ((void *)0);
}

extern void __rt_mutex_init(struct rt_mutex *lock, const char *name);
extern void rt_mutex_destroy(struct rt_mutex *lock);

extern void rt_mutex_lock(struct rt_mutex *lock);
extern int rt_mutex_lock_interruptible(struct rt_mutex *lock,
      int detect_deadlock);
extern int rt_mutex_timed_lock(struct rt_mutex *lock,
     struct hrtimer_sleeper *timeout,
     int detect_deadlock);

extern int rt_mutex_trylock(struct rt_mutex *lock);

extern void rt_mutex_unlock(struct rt_mutex *lock);
# 79 "include/linux/sched.h" 2


# 1 "include/linux/param.h" 1
# 82 "include/linux/sched.h" 2
# 1 "include/linux/resource.h" 1





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

struct rlimit {
 unsigned long rlim_cur;
 unsigned long rlim_max;
};
# 70 "include/linux/resource.h"
# 1 "include/asm/resource.h" 1



# 1 "include/asm-generic/resource.h" 1
# 5 "include/asm/resource.h" 2
# 71 "include/linux/resource.h" 2

int getrusage(struct task_struct *p, int who, struct rusage *ru);
# 83 "include/linux/sched.h" 2
# 1 "include/linux/timer.h" 1







struct tvec_t_base_s;

struct timer_list {
 struct list_head entry;
 unsigned long expires;

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

 struct tvec_t_base_s *base;
};

extern struct tvec_t_base_s boot_tvec_bases;
# 33 "include/linux/timer.h"
void init_timer(struct timer_list * timer);

static inline __attribute__((always_inline)) void setup_timer(struct timer_list * timer,
    void (*function)(unsigned long),
    unsigned long data)
{
 timer->function = function;
 timer->data = data;
 init_timer(timer);
}
# 54 "include/linux/timer.h"
static inline __attribute__((always_inline)) int timer_pending(const struct timer_list * timer)
{
 return timer->entry.next != ((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);
# 80 "include/linux/timer.h"
static inline __attribute__((always_inline)) void add_timer(struct timer_list *timer)
{
 do { if (__builtin_expect(!!((timer_pending(timer))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/timer.h", 82); panic("BUG!"); } while (0); } while(0);
 __mod_timer(timer, timer->expires);
}
# 96 "include/linux/timer.h"
extern void init_timers(void);
extern void run_local_timers(void);
struct hrtimer;
extern int it_real_fn(struct hrtimer *);
# 84 "include/linux/sched.h" 2
# 1 "include/linux/hrtimer.h" 1
# 19 "include/linux/hrtimer.h"
# 1 "include/linux/ktime.h" 1
# 46 "include/linux/ktime.h"
typedef union {
 s64 tv64;

 struct {



 s32 nsec, sec;

 } tv;

} ktime_t;
# 138 "include/linux/ktime.h"
static inline __attribute__((always_inline)) ktime_t ktime_set(const long secs, const unsigned long nsecs)
{
 return (ktime_t) { .tv = { .sec = secs, .nsec = nsecs } };
}
# 150 "include/linux/ktime.h"
static inline __attribute__((always_inline)) ktime_t ktime_sub(const ktime_t lhs, const ktime_t rhs)
{
 ktime_t res;

 res.tv64 = lhs.tv64 - rhs.tv64;
 if (res.tv.nsec < 0)
  res.tv.nsec += 1000000000L;

 return res;
}
# 168 "include/linux/ktime.h"
static inline __attribute__((always_inline)) ktime_t ktime_add(const ktime_t add1, const ktime_t add2)
{
 ktime_t res;

 res.tv64 = add1.tv64 + add2.tv64;
# 181 "include/linux/ktime.h"
 if (res.tv.nsec >= 1000000000L)
  res.tv64 += (u32)-1000000000L;

 return res;
}
# 194 "include/linux/ktime.h"
extern ktime_t ktime_add_ns(const ktime_t kt, u64 nsec);







static inline __attribute__((always_inline)) ktime_t timespec_to_ktime(const struct timespec ts)
{
 return (ktime_t) { .tv = { .sec = (s32)ts.tv_sec,
          .nsec = (s32)ts.tv_nsec } };
}







static inline __attribute__((always_inline)) ktime_t timeval_to_ktime(const struct timeval tv)
{
 return (ktime_t) { .tv = { .sec = (s32)tv.tv_sec,
       .nsec = (s32)tv.tv_usec * 1000 } };
}







static inline __attribute__((always_inline)) struct timespec ktime_to_timespec(const ktime_t kt)
{
 return (struct timespec) { .tv_sec = (time_t) kt.tv.sec,
       .tv_nsec = (long) kt.tv.nsec };
}







static inline __attribute__((always_inline)) struct timeval ktime_to_timeval(const ktime_t kt)
{
 return (struct timeval) {
  .tv_sec = (time_t) kt.tv.sec,
  .tv_usec = (suseconds_t) (kt.tv.nsec / 1000L) };
}







static inline __attribute__((always_inline)) u64 ktime_to_ns(const ktime_t kt)
{
 return (u64) kt.tv.sec * 1000000000L + kt.tv.nsec;
}
# 268 "include/linux/ktime.h"
extern void ktime_get_ts(struct timespec *ts);
# 20 "include/linux/hrtimer.h" 2







enum hrtimer_mode {
 HRTIMER_ABS,
 HRTIMER_REL,
};

enum hrtimer_restart {
 HRTIMER_NORESTART,
 HRTIMER_RESTART,
};



struct hrtimer_base;
# 52 "include/linux/hrtimer.h"
struct hrtimer {
 struct rb_node node;
 ktime_t expires;
 int (*function)(struct hrtimer *);
 struct hrtimer_base *base;
};
# 66 "include/linux/hrtimer.h"
struct hrtimer_sleeper {
 struct hrtimer timer;
 struct task_struct *task;
};
# 85 "include/linux/hrtimer.h"
struct hrtimer_base {
 clockid_t index;
 spinlock_t lock;
 struct rb_root active;
 struct rb_node *first;
 ktime_t resolution;
 ktime_t (*get_time)(void);
 ktime_t (*get_softirq_time)(void);
 struct hrtimer *curr_timer;
 ktime_t softirq_time;
 struct lock_class_key lock_key;
};
# 108 "include/linux/hrtimer.h"
extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
    enum hrtimer_mode mode);


extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
    const enum hrtimer_mode mode);
extern int hrtimer_cancel(struct hrtimer *timer);
extern int hrtimer_try_to_cancel(struct hrtimer *timer);




extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);





static inline __attribute__((always_inline)) int hrtimer_active(const struct hrtimer *timer)
{
 return ((struct rb_node *)((&timer->node)->rb_parent_color & ~3)) != &timer->node;
}


extern unsigned long
hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);


extern long hrtimer_nanosleep(struct timespec *rqtp,
         struct timespec *rmtp,
         const enum hrtimer_mode mode,
         const clockid_t clockid);
extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);

extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
     struct task_struct *tsk);


extern void hrtimer_run_queues(void);


extern void __attribute__ ((__section__ (".init.text"))) hrtimers_init(void);
# 85 "include/linux/sched.h" 2



struct exec_domain;
struct futex_pi_state;
# 107 "include/linux/sched.h"
extern unsigned long avenrun[];
# 121 "include/linux/sched.h"
extern unsigned long total_forks;
extern int nr_threads;
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_active(void);
extern unsigned long nr_iowait(void);
extern unsigned long weighted_cpuload(const int cpu);
# 186 "include/linux/sched.h"
extern rwlock_t tasklist_lock;
extern spinlock_t mmlist_lock;

struct task_struct;

extern void sched_init(void);
extern void sched_init_smp(void);
extern void init_idle(struct task_struct *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 void softlockup_tick(void);
extern void spawn_softlockup_task(void);
extern void touch_softlockup_watchdog(void);
# 235 "include/linux/sched.h"
extern int in_sched_functions(unsigned long addr);


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

struct nsproxy;




extern int sysctl_max_map_count;

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




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

struct work_struct {
 unsigned long pending;
 struct list_head entry;
 void (*func)(void *);
 void *data;
 void *wq_data;
 struct timer_list timer;
};

struct execute_work {
 struct work_struct work;
};
# 57 "include/linux/workqueue.h"
extern struct workqueue_struct *__create_workqueue(const char *name,
          int singlethread);



extern void destroy_workqueue(struct workqueue_struct *wq);

extern int queue_work(struct workqueue_struct *wq, struct work_struct *work);
extern int queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay);
extern int queue_delayed_work_on(int cpu, 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 int schedule_on_each_cpu(void (*func)(void *info), void *info);
extern void flush_scheduled_work(void);
extern int current_is_keventd(void);
extern int keventd_up(void);

extern void init_workqueues(void);
void cancel_rearming_delayed_work(struct work_struct *work);
void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
           struct work_struct *);
int execute_in_process_context(void (*fn)(void *), void *,
          struct execute_work *);






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;
}
# 6 "include/linux/aio.h" 2
# 1 "include/linux/aio_abi.h" 1
# 32 "include/linux/aio_abi.h"
typedef unsigned long aio_context_t;

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




 IOCB_CMD_NOOP = 6,
 IOCB_CMD_PREADV = 7,
 IOCB_CMD_PWRITEV = 8,
};


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

 __u64 aio_data;
 __u32 aio_key, aio_reserved1;



 __u16 aio_lio_opcode;
 __s16 aio_reqprio;
 __u32 aio_fildes;

 __u64 aio_buf;
 __u64 aio_nbytes;
 __s64 aio_offset;


 __u64 aio_reserved2;
 __u64 aio_reserved3;
};
# 7 "include/linux/aio.h" 2
# 1 "include/linux/uio.h" 1
# 20 "include/linux/uio.h"
struct iovec
{
 void *iov_base;
 __kernel_size_t iov_len;
};



struct kvec {
 void *iov_base;
 size_t iov_len;
};
# 54 "include/linux/uio.h"
static inline __attribute__((always_inline)) size_t iov_length(const struct iovec *iov, unsigned long nr_segs)
{
 unsigned long seg;
 size_t ret = 0;

 for (seg = 0; seg < nr_segs; seg++)
  ret += iov[seg].iov_len;
 return ret;
}

unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to);
# 8 "include/linux/aio.h" 2







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

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

 union {
  void *user;
  struct task_struct *tsk;
 } ki_obj;

 __u64 ki_user_data;
 wait_queue_t ki_wait;
 loff_t ki_pos;

 void *private;

 unsigned short ki_opcode;
 size_t ki_nbytes;
 char *ki_buf;
 size_t ki_left;
 long ki_retried;
 struct iovec ki_inline_vec;
  struct iovec *ki_iovec;
  unsigned long ki_nr_segs;
  unsigned long ki_cur_seg;

 struct list_head ki_list;

};
# 144 "include/linux/aio.h"
struct aio_ring {
 unsigned id;
 unsigned nr;
 unsigned head;
 unsigned tail;

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


 struct io_event io_events[0];
};




struct aio_ring_info {
 unsigned long mmap_base;
 unsigned long mmap_size;

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

 unsigned nr, tail;

 struct page *internal_pages[8];
};

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


 unsigned long user_id;
 struct kioctx *next;

 wait_queue_head_t wait;

 spinlock_t ctx_lock;

 int reqs_active;
 struct list_head active_reqs;
 struct list_head run_list;


 unsigned max_reqs;

 struct aio_ring_info ring_info;

 struct work_struct wq;
};


extern unsigned aio_max_size;

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



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


extern unsigned long aio_nr;
extern unsigned long aio_max_nr;
# 251 "include/linux/sched.h" 2

extern unsigned long
arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
         unsigned long, unsigned long);
extern unsigned long
arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
     unsigned long len, unsigned long pgoff,
     unsigned long flags);
extern void arch_unmap_area(struct mm_struct *, unsigned long);
extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
# 284 "include/linux/sched.h"
typedef unsigned long mm_counter_t;
# 300 "include/linux/sched.h"
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 mm_struct *mm, unsigned long addr);
 unsigned long mmap_base;
 unsigned long task_size;
 unsigned long cached_hole_size;
 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;







 mm_counter_t _file_rss;
 mm_counter_t _anon_rss;

 unsigned long hiwater_rss;
 unsigned long hiwater_vm;

 unsigned long total_vm, locked_vm, shared_vm, exec_vm;
 unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
 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 saved_auxv[44];

 unsigned dumpable:2;
 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 sighand_struct {
 atomic_t count;
 struct k_sigaction action[64];
 spinlock_t siglock;
};

struct pacct_struct {
 int ac_flag;
 long ac_exitcode;
 unsigned long ac_mem;
 cputime_t ac_utime, ac_stime;
 unsigned long ac_minflt, ac_majflt;
};
# 381 "include/linux/sched.h"
struct signal_struct {
 atomic_t count;
 atomic_t live;

 wait_queue_head_t wait_chldexit;


 struct task_struct *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;


 struct hrtimer real_timer;
 struct task_struct *tsk;
 ktime_t it_real_incr;


 cputime_t it_prof_expires, it_virt_expires;
 cputime_t it_prof_incr, it_virt_incr;


 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;







 unsigned long long sched_time;
# 455 "include/linux/sched.h"
 struct rlimit rlim[15];

 struct list_head cpu_timers[3];
# 471 "include/linux/sched.h"
};
# 514 "include/linux/sched.h"
struct user_struct {
 atomic_t __count;
 atomic_t processes;
 atomic_t files;
 atomic_t sigpending;





 unsigned long mq_bytes;
 unsigned long locked_shm;







 struct list_head uidhash_list;
 uid_t uid;
};

extern struct user_struct *find_user(uid_t);

extern struct user_struct root_user;


struct backing_dev_info;
struct reclaim_state;
# 592 "include/linux/sched.h"
static inline __attribute__((always_inline)) int sched_info_on(void)
{






 return 0;

}

enum idle_type
{
 SCHED_IDLE,
 NOT_IDLE,
 NEWLY_IDLE,
 MAX_IDLE_TYPES
};
# 721 "include/linux/sched.h"
struct io_context;
struct cpuset;



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







static inline __attribute__((always_inline)) void prefetch_stack(struct task_struct *t) { }


struct audit_context;
struct mempolicy;
struct pipe_inode_info;
struct uts_namespace;

enum sleep_type {
 SLEEP_NORMAL,
 SLEEP_NONINTERACTIVE,
 SLEEP_INTERACTIVE,
 SLEEP_INTERRUPTED,
};

struct prio_array;

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

 int lock_depth;






 int load_weight;
 int prio, static_prio, normal_prio;
 struct list_head run_list;
 struct prio_array *array;

 unsigned short ioprio;



 unsigned long sleep_avg;
 unsigned long long timestamp, last_ran;
 unsigned long long sched_time;
 enum sleep_type sleep_type;

 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;
# 843 "include/linux/sched.h"
 struct task_struct *real_parent;
 struct task_struct *parent;




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


 struct pid_link pids[PIDTYPE_MAX];
 struct list_head thread_group;

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

 unsigned long rt_priority;
 cputime_t utime, stime;
 unsigned long nvcsw, nivcsw;
 struct timespec start_time;

 unsigned long min_flt, maj_flt;

   cputime_t it_prof_expires, it_virt_expires;
 unsigned long long it_sched_expires;
 struct list_head cpu_timers[3];


 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;
# 892 "include/linux/sched.h"
 unsigned char fpu_counter;
 int oomkilladj;
 char comm[16];




 int link_count, total_link_count;





 struct thread_struct thread;

 struct fs_struct *fs;

 struct files_struct *files;

 struct nsproxy *nsproxy;

 struct signal_struct *signal;
 struct sighand_struct *sighand;

 sigset_t blocked, real_blocked;
 sigset_t saved_sigmask;
 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;
 seccomp_t seccomp;


    u32 parent_exec_id;
    u32 self_exec_id;

 spinlock_t alloc_lock;


 spinlock_t pi_lock;



 struct plist_head pi_waiters;

 struct rt_mutex_waiter *pi_blocked_on;
# 974 "include/linux/sched.h"
 void *journal_info;


 struct reclaim_state *reclaim_state;

 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;
# 1009 "include/linux/sched.h"
 struct robust_list_head *robust_list;



 struct list_head pi_state_list;
 struct futex_pi_state *pi_state_cache;

 atomic_t fs_excl;
 struct rcu_head rcu;




 struct pipe_inode_info *splice_pipe;



};

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

static inline __attribute__((always_inline)) struct pid *task_pid(struct task_struct *task)
{
 return task->pids[PIDTYPE_PID].pid;
}

static inline __attribute__((always_inline)) struct pid *task_tgid(struct task_struct *task)
{
 return task->group_leader->pids[PIDTYPE_PID].pid;
}

static inline __attribute__((always_inline)) struct pid *task_pgrp(struct task_struct *task)
{
 return task->group_leader->pids[PIDTYPE_PGID].pid;
}

static inline __attribute__((always_inline)) struct pid *task_session(struct task_struct *task)
{
 return task->group_leader->pids[PIDTYPE_SID].pid;
}
# 1061 "include/linux/sched.h"
static inline __attribute__((always_inline)) int pid_alive(struct task_struct *p)
{
 return p->pids[PIDTYPE_PID].pid != ((void *)0);
}







static inline __attribute__((always_inline)) int is_init(struct task_struct *tsk)
{
 return tsk->pid == 1;
}

extern struct pid *cad_pid;

extern void free_task(struct task_struct *tsk);


extern void __put_task_struct(struct task_struct *t);

static inline __attribute__((always_inline)) void put_task_struct(struct task_struct *t)
{
 if ((atomic_sub_return(1, (&t->usage)) == 0))
  __put_task_struct(t);
}
# 1147 "include/linux/sched.h"
static inline __attribute__((always_inline)) int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
{
 if (!(__builtin_constant_p((0)) ? __constant_test_bit(((0)),((new_mask).bits)) : __test_bit(((0)),((new_mask).bits))))
  return -22;
 return 0;
}


extern unsigned long long sched_clock(void);
extern unsigned long long
current_sched_time(const struct task_struct *current_task);
# 1169 "include/linux/sched.h"
static inline __attribute__((always_inline)) void idle_task_exit(void) {}


extern void sched_idle_next(void);


extern int rt_mutex_getprio(struct task_struct *p);
extern void rt_mutex_setprio(struct task_struct *p, int prio);
extern void rt_mutex_adjust_pi(struct task_struct *p);
# 1186 "include/linux/sched.h"
extern void set_user_nice(struct task_struct *p, long nice);
extern int task_prio(const struct task_struct *p);
extern int task_nice(const struct task_struct *p);
extern int can_nice(const struct task_struct *p, const int nice);
extern int task_curr(const struct task_struct *p);
extern int idle_cpu(int cpu);
extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
extern struct task_struct *idle_task(int cpu);
extern struct task_struct *curr_task(int cpu);
extern void set_curr_task(int cpu, struct task_struct *p);

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(unsigned long ticks);

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(struct task_struct * p, int clone_flags);
extern void sched_exit(struct task_struct * 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 { do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (0); } while (0);
 ret = dequeue_signal(tsk, mask, info);
 do { do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (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_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
extern int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
extern int kill_pgrp(struct pid *pid, int sig, int priv);
extern int kill_pid(struct pid *pid, int sig, int priv);
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_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, struct k_sigaction *, struct k_sigaction *);
extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);

static inline __attribute__((always_inline)) int kill_cad_pid(int sig, int priv)
{
 return kill_pid(cad_pid, sig, priv);
}






static inline __attribute__((always_inline)) int is_si_special(const struct siginfo *info)
{
 return info <= ((struct siginfo *) 2);
}



static inline __attribute__((always_inline)) int on_sig_stack(unsigned long sp)
{
 return (sp - (get_current())->sas_ss_sp < (get_current())->sas_ss_size);
}

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




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_sub_return(1, (&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_files(struct task_struct *);
extern void __cleanup_signal(struct signal_struct *);
extern void __cleanup_sighand(struct sighand_struct *);
extern void exit_itimers(struct signal_struct *);

extern void do_group_exit(int);

extern void daemonize(const char *, ...);
extern int allow_signal(int);
extern int disallow_signal(int);
extern struct task_struct *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 *);
struct task_struct *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);
# 1410 "include/linux/sched.h"
static inline __attribute__((always_inline)) int has_group_leader_pid(struct task_struct *p)
{
 return p->pid == p->tgid;
}

static inline __attribute__((always_inline)) struct task_struct *next_thread(const struct task_struct *p)
{
 return ({ const typeof( ((struct task_struct *)0)->thread_group ) *__mptr = (({ typeof(p->thread_group.next) _________p1 = p->thread_group.next; do { } while(0); (_________p1); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,thread_group) );});

}

static inline __attribute__((always_inline)) int thread_group_empty(struct task_struct *p)
{
 return list_empty(&p->thread_group);
}
# 1438 "include/linux/sched.h"
static inline __attribute__((always_inline)) void task_lock(struct task_struct *p)
{
 do { do { } while (0); (void)0; (void)(&p->alloc_lock); } while (0);
}

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

extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
       unsigned long *flags);

static inline __attribute__((always_inline)) void unlock_task_sighand(struct task_struct *tsk,
      unsigned long *flags)
{
 do { do { if (((*flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (0); } while (0);
}






static inline __attribute__((always_inline)) void setup_thread_stack(struct task_struct *p, struct task_struct *org)
{
 *(p)->thread_info = *(org)->thread_info;
 (p)->thread_info->task = p;
}

static inline __attribute__((always_inline)) unsigned long *end_of_stack(struct task_struct *p)
{
 return (unsigned long *)(p->thread_info + 1);
}






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_ti_thread_flag(current_thread_info(), 3)), 0);
}
# 1530 "include/linux/sched.h"
extern int cond_resched(void);
extern int cond_resched_lock(spinlock_t * lock);
extern int cond_resched_softirq(void);
# 1548 "include/linux/sched.h"
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);
# 1581 "include/linux/sched.h"
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 = 0;
 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);

# 1 "include/linux/sysdev.h" 1
# 24 "include/linux/sysdev.h"
# 1 "include/linux/kobject.h" 1
# 22 "include/linux/kobject.h"
# 1 "include/linux/sysfs.h" 1
# 16 "include/linux/sysfs.h"
struct kobject;
struct module;

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

struct attribute_group {
 const char * name;
 struct attribute ** attrs;
};
# 52 "include/linux/sysfs.h"
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;
 struct iattr * s_iattr;
 atomic_t s_event;
};
# 90 "include/linux/sysfs.h"
extern int __attribute__((warn_unused_result))
sysfs_create_dir(struct kobject *);

extern void
sysfs_remove_dir(struct kobject *);

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

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

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

extern int __attribute__((warn_unused_result))
sysfs_chmod_file(struct kobject *kobj, struct attribute *attr, mode_t mode);

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

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

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

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

int __attribute__((warn_unused_result)) sysfs_create_group(struct kobject *,
     const struct attribute_group *);
void sysfs_remove_group(struct kobject *, const struct attribute_group *);
void sysfs_notify(struct kobject * k, char *dir, char *attr);

extern int __attribute__((warn_unused_result)) sysfs_init(void);
# 23 "include/linux/kobject.h" 2
# 35 "include/linux/kobject.h"
extern char uevent_helper[];


extern u64 uevent_seqnum;


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,
};

struct kobject {
 const 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;
 wait_queue_head_t poll;
};

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

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

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

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

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

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

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

extern struct kobject *kobject_add_dir(struct kobject *, const char *);

extern char * kobject_get_path(struct kobject *, gfp_t);

struct kobj_type {
 void (*release)(struct kobject *);
 struct sysfs_ops * sysfs_ops;
 struct attribute ** default_attrs;
};
# 114 "include/linux/kobject.h"
struct kset_uevent_ops {
 int (*filter)(struct kset *kset, struct kobject *kobj);
 const char *(*name)(struct kset *kset, struct kobject *kobj);
 int (*uevent)(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;
 spinlock_t list_lock;
 struct kobject kobj;
 struct kset_uevent_ops * uevent_ops;
};


extern void kset_init(struct kset * k);
extern int __attribute__((warn_unused_result)) kset_add(struct kset * k);
extern int __attribute__((warn_unused_result)) 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 - __builtin_offsetof(struct kset,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 *);
# 170 "include/linux/kobject.h"
struct subsystem {
 struct kset kset;
 struct rw_semaphore rwsem;
};
# 193 "include/linux/kobject.h"
extern struct subsystem kernel_subsys;

extern struct subsystem hypervisor_subsys;
# 242 "include/linux/kobject.h"
extern void subsystem_init(struct subsystem *);
extern int __attribute__((warn_unused_result)) 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 - __builtin_offsetof(struct subsystem,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 __attribute__((warn_unused_result)) subsys_create_file(struct subsystem * ,
     struct subsys_attribute *);
# 273 "include/linux/kobject.h"
static inline __attribute__((always_inline)) void kobject_uevent(struct kobject *kobj, enum kobject_action action) { }

static inline __attribute__((always_inline)) int add_uevent_var(char **envp, int num_envp, int *cur_index,
          char *buffer, int buffer_size, int *cur_len,
          const char *format, ...)
{ return 0; }
# 25 "include/linux/sysdev.h" 2
# 1 "include/linux/pm.h" 1
# 34 "include/linux/pm.h"
typedef int pm_request_t;
# 43 "include/linux/pm.h"
typedef int pm_dev_t;
# 56 "include/linux/pm.h"
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,
};
# 75 "include/linux/pm.h"
struct pm_dev;

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




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

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

 struct list_head entry;
};







extern void (*pm_idle)(void);
extern void (*pm_power_off)(void);

typedef int suspend_state_t;







typedef int suspend_disk_method_t;
# 123 "include/linux/pm.h"
struct pm_ops {
 suspend_disk_method_t pm_disk_mode;
 int (*valid)(suspend_state_t state);
 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 struct pm_ops *pm_ops;
extern int pm_suspend(suspend_state_t state);






struct device;

typedef struct pm_message {
 int event;
} pm_message_t;
# 205 "include/linux/pm.h"
struct dev_pm_info {
 pm_message_t power_state;
 unsigned can_wakeup:1;







};

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

extern int device_power_down(pm_message_t state);
extern void device_power_up(void);
extern void device_resume(void);
# 245 "include/linux/pm.h"
static inline __attribute__((always_inline)) int device_suspend(pm_message_t state)
{
 return 0;
}




static inline __attribute__((always_inline)) int dpm_runtime_suspend(struct device * dev, pm_message_t state)
{
 return 0;
}

static inline __attribute__((always_inline)) void dpm_runtime_resume(struct device * dev)
{
}
# 26 "include/linux/sysdev.h" 2


struct sys_device;

struct sysdev_class {
 struct list_head drivers;


 int (*shutdown)(struct sys_device *);
 int (*suspend)(struct sys_device *, pm_message_t state);
 int (*resume)(struct sys_device *);
 struct kset kset;
};

struct sysdev_class_attribute {
 struct attribute attr;
 ssize_t (*show)(struct sysdev_class *, char *);
 ssize_t (*store)(struct sysdev_class *, const char *, size_t);
};
# 54 "include/linux/sysdev.h"
extern int sysdev_class_register(struct sysdev_class *);
extern void sysdev_class_unregister(struct sysdev_class *);

extern int sysdev_class_create_file(struct sysdev_class *,
 struct sysdev_class_attribute *);
extern void sysdev_class_remove_file(struct sysdev_class *,
 struct sysdev_class_attribute *);




struct sysdev_driver {
 struct list_head entry;
 int (*add)(struct sys_device *);
 int (*remove)(struct sys_device *);
 int (*shutdown)(struct sys_device *);
 int (*suspend)(struct sys_device *, pm_message_t state);
 int (*resume)(struct sys_device *);
};


extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);







struct sys_device {
 u32 id;
 struct sysdev_class * cls;
 struct kobject kobj;
};

extern int sysdev_register(struct sys_device *);
extern void sysdev_unregister(struct sys_device *);


struct sysdev_attribute {
 struct attribute attr;
 ssize_t (*show)(struct sys_device *, char *);
 ssize_t (*store)(struct sys_device *, const char *, size_t);
};
# 108 "include/linux/sysdev.h"
extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
# 1607 "include/linux/sched.h" 2
extern int sched_mc_power_savings, sched_smt_power_savings;
extern struct sysdev_attribute attr_sched_mc_power_savings, attr_sched_smt_power_savings;
extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls);

extern void normalize_rt_tasks(void);
# 1681 "include/linux/sched.h"
static inline __attribute__((always_inline)) int frozen(struct task_struct *p) { return 0; }
static inline __attribute__((always_inline)) int freezing(struct task_struct *p) { return 0; }
static inline __attribute__((always_inline)) void freeze(struct task_struct *p) { do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/sched.h", 1683); panic("BUG!"); } while (0); }
static inline __attribute__((always_inline)) int thaw_process(struct task_struct *p) { return 1; }
static inline __attribute__((always_inline)) void frozen_process(struct task_struct *p) { do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/sched.h", 1685); panic("BUG!"); } while (0); }

static inline __attribute__((always_inline)) void refrigerator(void) {}
static inline __attribute__((always_inline)) int freeze_processes(void) { do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/sched.h", 1688); panic("BUG!"); } while (0); return 0; }
static inline __attribute__((always_inline)) void thaw_processes(void) {}

static inline __attribute__((always_inline)) int try_to_freeze(void) { return 0; }
# 13 "include/asm/uaccess.h" 2
# 1 "include/linux/mm.h" 1
# 14 "include/linux/mm.h"
# 1 "include/linux/prio_tree.h" 1
# 14 "include/linux/prio_tree.h"
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);
}
# 84 "include/linux/prio_tree.h"
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);
# 15 "include/linux/mm.h" 2
# 1 "include/linux/fs.h" 1
# 9 "include/linux/fs.h"
# 1 "include/linux/limits.h" 1
# 10 "include/linux/fs.h" 2
# 1 "include/linux/ioctl.h" 1



# 1 "include/asm/ioctl.h" 1
# 1 "include/asm-generic/ioctl.h" 1
# 51 "include/asm-generic/ioctl.h"
extern unsigned int __invalid_size_argument_for_IOC;
# 1 "include/asm/ioctl.h" 2
# 5 "include/linux/ioctl.h" 2
# 11 "include/linux/fs.h" 2
# 35 "include/linux/fs.h"
struct files_stat_struct {
 int nr_files;
 int nr_free_files;
 int max_files;
};
extern struct files_stat_struct files_stat;
extern int get_max_files(void);

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;
# 270 "include/linux/fs.h"
# 1 "include/linux/kdev_t.h" 1
# 21 "include/linux/kdev_t.h"
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;
}
# 271 "include/linux/fs.h" 2
# 1 "include/linux/dcache.h" 1
# 12 "include/linux/dcache.h"
struct nameidata;
struct vfsmount;
# 33 "include/linux/dcache.h"
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 hlist_node d_hash;
 struct dentry *d_parent;
 struct qstr d_name;

 struct list_head d_lru;



 union {
  struct list_head d_child;
   struct rcu_head d_rcu;
 } d_u;
 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;



 int d_mounted;
 unsigned char d_iname[36];
};







enum dentry_d_lock_class
{
 DENTRY_D_LOCK_NORMAL,
 DENTRY_D_LOCK_NESTED
};

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 *);
};
# 179 "include/linux/dcache.h"
extern spinlock_t dcache_lock;
# 197 "include/linux/dcache.h"
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); (void)0; (void)(&dcache_lock); } while (0);
 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
  __d_drop(dentry);
 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
 do { do { } while (0); (void)0; (void)(&dcache_lock); } 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 struct dentry * d_materialise_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_for_umount(struct super_block *);
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 *);
# 262 "include/linux/dcache.h"
static inline __attribute__((always_inline)) void d_add(struct dentry *entry, struct inode *inode)
{
 d_instantiate(entry, inode);
 d_rehash(entry);
}
# 276 "include/linux/dcache.h"
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 struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);


extern int d_validate(struct dentry *, struct dentry *);

extern char * d_path(struct dentry *, struct vfsmount *, char *, int);
# 313 "include/linux/dcache.h"
static inline __attribute__((always_inline)) struct dentry *dget(struct dentry *dentry)
{
 if (dentry) {
  do { if (__builtin_expect(!!((!((&dentry->d_count)->counter))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/dcache.h", 316); panic("BUG!"); } while (0); } while(0);
  atomic_inc(&dentry->d_count);
 }
 return dentry;
}

extern struct dentry * dget_locked(struct dentry *);
# 331 "include/linux/dcache.h"
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); (void)0; (void)(&dentry->d_lock); } while (0);
 ret = dget(dentry->d_parent);
 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } 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 vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);

extern int sysctl_vfs_cache_pressure;
# 272 "include/linux/fs.h" 2
# 1 "include/linux/stat.h" 1





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



struct stat {
 unsigned short st_dev;
 unsigned short __pad1;
 unsigned long st_ino;
 unsigned short st_mode;
 unsigned short st_nlink;
 unsigned short st_uid;
 unsigned short st_gid;
 unsigned short st_rdev;
 unsigned short __pad2;
 unsigned long st_size;
 unsigned long st_blksize;
 unsigned long st_blocks;
 unsigned long st_atime;
 unsigned long __unused1;
 unsigned long st_mtime;
 unsigned long __unused2;
 unsigned long st_ctime;
 unsigned long __unused3;
 unsigned long __unused4;
 unsigned long __unused5;
};




struct stat64 {
 unsigned long long st_dev;
 unsigned char __pad1[4];


 unsigned long __st_ino;

 unsigned int st_mode;
 unsigned int st_nlink;

 unsigned long st_uid;
 unsigned long st_gid;

 unsigned long long st_rdev;
 unsigned char __pad2[4];

 long long st_size;
 unsigned long st_blksize;

 long 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 long st_ino;
};
# 7 "include/linux/stat.h" 2
# 59 "include/linux/stat.h"
struct kstat {
 u64 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 long blocks;
};
# 273 "include/linux/fs.h" 2



# 1 "include/linux/radix-tree.h" 1
# 29 "include/linux/radix-tree.h"
struct radix_tree_root {
 unsigned int height;
 gfp_t gfp_mask;
 struct radix_tree_node *rnode;
};
# 51 "include/linux/radix-tree.h"
int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
void **radix_tree_lookup_slot(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(gfp_t gfp_mask);
void radix_tree_init(void);
void *radix_tree_tag_set(struct radix_tree_root *root,
   unsigned long index, unsigned int tag);
void *radix_tree_tag_clear(struct radix_tree_root *root,
   unsigned long index, unsigned int tag);
int radix_tree_tag_get(struct radix_tree_root *root,
   unsigned long index, unsigned int tag);
unsigned int
radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
  unsigned long first_index, unsigned int max_items,
  unsigned int tag);
int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);

static inline __attribute__((always_inline)) void radix_tree_preload_end(void)
{
 do { } while (0);
}
# 277 "include/linux/fs.h" 2
# 286 "include/linux/fs.h"
struct hd_geometry;
struct iovec;
struct nameidata;
struct kiocb;
struct pipe_inode_info;
struct poll_table_struct;
struct kstatfs;
struct vm_area_struct;
struct vfsmount;

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 void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
   ssize_t bytes, void *private);
# 335 "include/linux/fs.h"
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;






 struct file *ia_file;
};




# 1 "include/linux/quota.h" 1
# 44 "include/linux/quota.h"
typedef __kernel_uid32_t qid_t;
typedef __u64 qsize_t;

extern spinlock_t dq_data_lock;
# 105 "include/linux/quota.h"
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;
};
# 126 "include/linux/quota.h"
struct if_dqinfo {
 __u64 dqi_bgrace;
 __u64 dqi_igrace;
 __u32 dqi_flags;
 __u32 dqi_valid;
};





# 1 "include/linux/dqblk_xfs.h" 1
# 50 "include/linux/dqblk_xfs.h"
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;
# 137 "include/linux/dqblk_xfs.h"
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;
# 138 "include/linux/quota.h" 2
# 1 "include/linux/dqblk_v1.h" 1
# 21 "include/linux/dqblk_v1.h"
struct v1_mem_dqinfo {
};
# 139 "include/linux/quota.h" 2
# 1 "include/linux/dqblk_v2.h" 1
# 20 "include/linux/dqblk_v2.h"
struct v2_mem_dqinfo {
 unsigned int dqi_blocks;
 unsigned int dqi_free_blk;
 unsigned int dqi_free_entry;
};
# 140 "include/linux/quota.h" 2
# 151 "include/linux/quota.h"
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;
# 213 "include/linux/quota.h"
struct dquot {
 struct hlist_node dq_hash;
 struct list_head dq_inuse;
 struct list_head dq_free;
 struct list_head dq_dirty;
 struct mutex 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 mutex dqio_mutex;
 struct mutex dqonoff_mutex;
 struct rw_semaphore dqptr_sem;
 struct inode *files[2];
 struct mem_dqinfo info[2];
 struct quota_format_ops *ops[2];
};


int mark_dquot_dirty(struct dquot *dquot);
# 307 "include/linux/quota.h"
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;
};
# 357 "include/linux/fs.h" 2
# 384 "include/linux/fs.h"
enum positive_aop_returns {
 AOP_WRITEPAGE_ACTIVATE = 0x80000,
 AOP_TRUNCATED_PAGE = 0x80001,
};




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 *);
 void (*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);
 void (*invalidatepage) (struct page *, unsigned long);
 int (*releasepage) (struct page *, gfp_t);
 ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
   loff_t offset, unsigned long nr_segs);
 struct page* (*get_xip_page)(struct address_space *, sector_t,
   int);

 int (*migratepage) (struct address_space *,
   struct page *, struct page *);
};

struct backing_dev_info;
struct address_space {
 struct inode *host;
 struct radix_tree_root page_tree;
 rwlock_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;
 const 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 mutex bd_mutex;
 struct mutex bd_mount_mutex;
 struct list_head bd_inodes;
 void * bd_holder;
 int bd_holders;

 struct list_head bd_holder_list;

 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;
};
# 495 "include/linux/fs.h"
enum bdev_bd_mutex_lock_class
{
 BD_MUTEX_NORMAL,
 BD_MUTEX_WHOLE,
 BD_MUTEX_PARTITION
};
# 510 "include/linux/fs.h"
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;
}
# 543 "include/linux/fs.h"
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_version;
 blkcnt_t i_blocks;
 unsigned short i_bytes;
 spinlock_t i_lock;
 struct mutex i_mutex;
 struct rw_semaphore i_alloc_sem;
 struct inode_operations *i_op;
 const 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;
 union {
  struct pipe_inode_info *i_pipe;
  struct block_device *i_bdev;
  struct cdev *i_cdev;
 };
 int i_cindex;

 __u32 i_generation;
# 595 "include/linux/fs.h"
 unsigned long i_state;
 unsigned long dirtied_when;

 unsigned int i_flags;

 atomic_t i_writecount;



 void *i_private;



};
# 621 "include/linux/fs.h"
enum inode_i_mutex_lock_class
{
 I_MUTEX_NORMAL,
 I_MUTEX_PARENT,
 I_MUTEX_CHILD,
 I_MUTEX_XATTR,
 I_MUTEX_QUOTA
};

extern void inode_double_lock(struct inode *inode1, struct inode *inode2);
extern void inode_double_unlock(struct inode *inode1, struct inode *inode2);
# 643 "include/linux/fs.h"
static inline __attribute__((always_inline)) loff_t i_size_read(struct inode *inode)
{
# 662 "include/linux/fs.h"
 return inode->i_size;

}






static inline __attribute__((always_inline)) void i_size_write(struct inode *inode, loff_t i_size)
{
# 682 "include/linux/fs.h"
 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;
 struct pid *pid;
 enum pid_type pid_type;
 uid_t uid, euid;
 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 {




 union {
  struct list_head fu_list;
  struct rcu_head fu_rcuhead;
 } f_u;
 struct dentry *f_dentry;
 struct vfsmount *f_vfsmnt;
 const struct file_operations *f_op;
 atomic_t f_count;
 unsigned int f_flags;
 mode_t f_mode;
 loff_t f_pos;
 struct fown_struct f_owner;
 unsigned int f_uid, f_gid;
 struct file_ra_state f_ra;

 unsigned long f_version;




 void *private_data;



 struct list_head f_ep_links;
 spinlock_t f_ep_lock;

 struct address_space *f_mapping;
};
extern spinlock_t files_lock;
# 790 "include/linux/fs.h"
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 *);
 int (*fl_mylease)(struct file_lock *, struct file_lock *);
 int (*fl_change)(struct file_lock **, int);
};


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





# 1 "include/linux/nfs.h" 1
# 39 "include/linux/nfs.h"
 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
};


# 1 "include/linux/sunrpc/msg_prot.h" 1
# 18 "include/linux/sunrpc/msg_prot.h"
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,

 RPC_DROP_REPLY = 60000,
};

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
};
# 106 "include/linux/sunrpc/msg_prot.h"
typedef __be32 rpc_fraghdr;
# 131 "include/linux/nfs.h" 2






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);
}
# 165 "include/linux/nfs.h"
enum nfs3_stable_how {
 NFS_UNSTABLE = 0,
 NFS_DATA_SYNC = 1,
 NFS_FILE_SYNC = 2
};
# 7 "include/linux/nfs_fs_i.h" 2

struct nlm_lockowner;




struct nfs_lock_info {
 u32 state;
 struct nlm_lockowner *owner;
 struct list_head list;
};

struct nfs4_lock_state;
struct nfs4_lock_info {
 struct nfs4_lock_state *owner;
};
# 811 "include/linux/fs.h" 2

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;
  struct nfs4_lock_info nfs4_fl;
 } fl_u;
};
# 843 "include/linux/fs.h"
# 1 "include/linux/fcntl.h" 1



# 1 "include/asm/fcntl.h" 1
# 11 "include/asm/fcntl.h"
# 1 "include/asm-generic/fcntl.h" 1
# 114 "include/asm-generic/fcntl.h"
struct flock {
 short l_type;
 short l_whence;
 off_t l_start;
 off_t l_len;
 pid_t l_pid;

};
# 137 "include/asm-generic/fcntl.h"
struct flock64 {
 short l_type;
 short l_whence;
 loff_t l_start;
 loff_t l_len;
 pid_t l_pid;

};
# 12 "include/asm/fcntl.h" 2
# 5 "include/linux/fcntl.h" 2
# 844 "include/linux/fs.h" 2

extern int fcntl_getlk(struct file *, struct flock *);
extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
   struct flock *);


extern int fcntl_getlk64(struct file *, struct flock64 *);
extern int fcntl_setlk64(unsigned int, 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 int do_sync_file_range(struct file *file, loff_t offset, loff_t endbyte,
   unsigned int flags);


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 int posix_test_lock(struct file *, struct file_lock *, struct file_lock *);
extern int posix_lock_file_conf(struct file *, struct file_lock *, 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 int posix_unblock_lock(struct file *, 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 int lease_modify(struct file_lock **, int);
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);

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, struct pid *, enum pid_type, int force);
extern int f_setown(struct file *filp, unsigned long arg, int force);
extern void f_delown(struct file *filp);
extern pid_t f_getown(struct file *filp);
extern int send_sigurg(struct fown_struct *fown);
# 911 "include/linux/fs.h"
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 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 mutex s_lock;
 int s_count;
 int s_syncing;
 int s_need_sync_fs;
 atomic_t s_active;



 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 mutex s_vfs_rename_mutex;



 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 get_fs_excl(void)
{
 atomic_inc(&(get_current())->fs_excl);
}

static inline __attribute__((always_inline)) void put_fs_excl(void)
{
 atomic_dec(&(get_current())->fs_excl);
}

static inline __attribute__((always_inline)) int has_fs_excl(void)
{
 return ((&(get_current())->fs_excl)->counter);
}





static inline __attribute__((always_inline)) void lock_super(struct super_block * sb)
{
 get_fs_excl();
 mutex_lock(&sb->s_lock);
}

static inline __attribute__((always_inline)) void unlock_super(struct super_block * sb)
{
 put_fs_excl();
 mutex_unlock(&sb->s_lock);
}




extern int vfs_permission(struct nameidata *, int);
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);




extern int file_permission(struct file *, int);
# 1057 "include/linux/fs.h"
int generic_osync_inode(struct inode *, struct address_space *, int);







typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, 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 (*unlocked_ioctl) (struct file *, unsigned, unsigned long);
 long (*compat_ioctl) (struct file *, unsigned, unsigned long);
 int (*direct_access) (struct block_device *, sector_t, unsigned long *);
 int (*media_changed) (struct gendisk *);
 int (*revalidate_disk) (struct gendisk *);
 int (*getgeo)(struct block_device *, struct hd_geometry *);
 struct module *owner;
};
# 1089 "include/linux/fs.h"
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);
# 1112 "include/linux/fs.h"
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 *);
 ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, 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 *, fl_owner_t id);
 int (*release) (struct inode *, struct file *);
 int (*fsync) (struct file *, struct dentry *, int datasync);
 int (*aio_fsync) (struct kiocb *, int datasync);
 int (*fasync) (int, struct file *, int);
 int (*lock) (struct file *, int, struct file_lock *);
 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 *);
 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
};

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);
 void * (*follow_link) (struct dentry *, struct nameidata *);
 void (*put_link) (struct dentry *, struct nameidata *, void *);
 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 *);
 void (*truncate_range)(struct inode *, loff_t, loff_t);
};

struct seq_file;

ssize_t rw_copy_check_uvector(int type, const struct iovec * uvector,
    unsigned long nr_segs, unsigned long fast_segs,
    struct iovec *fast_pointer,
    struct iovec **ret_pointer);

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 dentry *, struct kstatfs *);
 int (*remount_fs) (struct super_block *, int *, char *);
 void (*clear_inode) (struct inode *);
 void (*umount_begin) (struct vfsmount *, int);

 int (*show_options)(struct seq_file *, struct vfsmount *);
 int (*show_stats)(struct seq_file *, struct vfsmount *);




};
# 1227 "include/linux/fs.h"
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 inc_nlink(struct inode *inode)
{
 inode->i_nlink++;
}

static inline __attribute__((always_inline)) void inode_inc_link_count(struct inode *inode)
{
 inc_nlink(inode);
 mark_inode_dirty(inode);
}

static inline __attribute__((always_inline)) void drop_nlink(struct inode *inode)
{
 inode->i_nlink--;
}

static inline __attribute__((always_inline)) void clear_nlink(struct inode *inode)
{
 inode->i_nlink = 0;
}

static inline __attribute__((always_inline)) void inode_dec_link_count(struct inode *inode)
{
 drop_nlink(inode);
 mark_inode_dirty(inode);
}

extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
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);
# 1360 "include/linux/fs.h"
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;
 int (*get_sb) (struct file_system_type *, int,
         const char *, void *, struct vfsmount *);
 void (*kill_sb) (struct super_block *);
 struct module *owner;
 struct file_system_type * next;
 struct list_head fs_supers;
 struct lock_class_key s_lock_key;
 struct lock_class_key s_umount_key;
};

extern int 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 vfsmount *mnt);
extern int get_sb_single(struct file_system_type *fs_type,
 int flags, void *data,
 int (*fill_super)(struct super_block *, void *, int),
 struct vfsmount *mnt);
extern int get_sb_nodev(struct file_system_type *fs_type,
 int flags, void *data,
 int (*fill_super)(struct super_block *, void *, int),
 struct vfsmount *mnt);
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);
extern int get_sb_pseudo(struct file_system_type *, char *,
 struct super_operations *ops, unsigned long,
 struct vfsmount *mnt);
extern int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
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 void umount_tree(struct vfsmount *, int, struct list_head *);
extern void release_mounts(struct list_head *);
extern long do_mount(char *, char *, char *, unsigned long, void *);
extern struct vfsmount *copy_tree(struct vfsmount *, struct dentry *, int);
extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
      struct vfsmount *);

extern int vfs_statfs(struct dentry *, struct kstatfs *);


extern struct subsystem fs_subsys;




extern int locks_mandatory_locked(struct inode *);
extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
# 1466 "include/linux/fs.h"
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, unsigned int time_attrs,
         struct file *filp);
extern long do_sys_open(int fdf, const char *filename, int flags,
   int mode);
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);
# 1520 "include/linux/fs.h"
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 block_device *open_partition_by_devnum(dev_t, unsigned);
extern const struct address_space_operations def_blk_aops;



extern const struct file_operations def_blk_fops;
extern const struct file_operations def_chr_fops;
extern const struct file_operations bad_sock_fops;
extern const 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 int blkdev_driver_ioctl(struct inode *inode, struct file *file,
          struct gendisk *disk, unsigned cmd,
          unsigned long arg);
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 blkdev_put_partition(struct block_device *);
extern int bd_claim(struct block_device *, void *);
extern void bd_release(struct block_device *);

extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
extern void bd_release_from_disk(struct block_device *, struct gendisk *);
# 1559 "include/linux/fs.h"
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 *,
      const 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 void chrdev_show(struct seq_file *,off_t);






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 blkdev_show(struct seq_file *,off_t);




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 const struct file_operations read_fifo_fops;
extern const struct file_operations write_fifo_fops;
extern const struct file_operations rdwr_fifo_fops;

extern int fs_may_remount_ro(struct super_block *);
# 1606 "include/linux/fs.h"
extern int check_disk_change(struct block_device *);
extern int __invalidate_device(struct block_device *);
extern int invalidate_partition(struct gendisk *, int);

extern int invalidate_inodes(struct super_block *);
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 invalidate_inode_pages2_range(struct address_space *mapping,
      unsigned long start, unsigned long end);
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 int filemap_write_and_wait_range(struct address_space *mapping,
            loff_t lstart, loff_t lend);
extern int wait_on_page_writeback_range(struct address_space *mapping,
    unsigned long start, unsigned long end);
extern int __filemap_fdatawrite_range(struct address_space *mapping,
    loff_t start, loff_t end, int sync_mode);

extern long do_fsync(struct file *file, int datasync);
extern void sync_supers(void);
extern void sync_filesystems(int wait);
extern void __fsync_super(struct super_block *sb);
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 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 struct file *create_read_pipe(struct file *f);
extern struct file *create_write_pipe(void);
extern void free_write_pipe(struct file *);

extern int open_namei(int dfd, 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 *);

# 1 "include/linux/err.h" 1
# 22 "include/linux/err.h"
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)-4095), 0);
}
# 1678 "include/linux/fs.h" 2


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 void generic_drop_inode(struct inode *inode);

extern struct inode *ilookup5_nowait(struct super_block *sb,
  unsigned long hashval, int (*test)(struct inode *, void *),
  void *data);
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 *, int);
extern int should_remove_suid(struct dentry *);
extern int remove_suid(struct dentry *);
extern void remove_dquot_ref(struct super_block *, int, struct list_head *);

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);
int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
extern ssize_t generic_file_aio_write_nolock(struct kiocb *, const struct iovec *,
  unsigned long, loff_t);
extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
  unsigned long *, loff_t, loff_t *, size_t, size_t);
extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
  unsigned long, loff_t, loff_t *, size_t, ssize_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);
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 ssize_t generic_file_splice_read(struct file *, loff_t *,
  struct pipe_inode_info *, size_t, unsigned int);
extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
  struct file *, loff_t *, size_t, unsigned int);
extern ssize_t generic_file_splice_write_nolock(struct pipe_inode_info *,
  struct file *, loff_t *, size_t, unsigned int);
extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
  struct file *out, loff_t *, size_t len, unsigned int flags);
extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
  size_t len, unsigned int flags);

extern void
file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
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);
# 1793 "include/linux/fs.h"
static inline __attribute__((always_inline)) int xip_truncate_page(struct address_space *mapping, loff_t from)
{
 return 0;
}


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


ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 struct block_device *bdev, const struct iovec *iov, loff_t offset,
 unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
 int lock_type);

enum {
 DIO_LOCKING = 1,
 DIO_NO_LOCKING,
 DIO_OWN_LOCKING,
};

static inline __attribute__((always_inline)) ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 loff_t offset, unsigned long nr_segs, get_block_t get_block,
 dio_iodone_t end_io)
{
 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
    nr_segs, get_block, end_io, DIO_LOCKING);
}

static inline __attribute__((always_inline)) ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 loff_t offset, unsigned long nr_segs, get_block_t get_block,
 dio_iodone_t end_io)
{
 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
    nr_segs, get_block, end_io, DIO_NO_LOCKING);
}

static inline __attribute__((always_inline)) ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 loff_t offset, unsigned long nr_segs, get_block_t get_block,
 dio_iodone_t end_io)
{
 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
    nr_segs, get_block, end_io, DIO_OWN_LOCKING);
}


extern const 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 void *page_follow_link_light(struct dentry *, struct nameidata *);
extern void page_put_link(struct dentry *, struct nameidata *, void *);
extern int __page_symlink(struct inode *inode, const char *symname, int len,
  gfp_t gfp_mask);
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_stat_fd(int dfd, char *, struct kstat *);
extern int vfs_lstat_fd(int dfd, 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 dentry *, 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 const struct file_operations simple_dir_operations;
extern struct inode_operations simple_dir_inode_operations;
struct tree_descr { char *name; const 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(struct file_system_type *, 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);
# 1924 "include/linux/fs.h"
extern int inode_change_ok(struct inode *, struct iattr *);
extern int __attribute__((warn_unused_result)) inode_setattr(struct inode *, struct iattr *);

extern void file_update_time(struct file *file);

static inline __attribute__((always_inline)) ino_t parent_ino(struct dentry *dentry)
{
 ino_t res;

 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
 res = dentry->d_parent->d_inode->i_ino;
 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } 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_expect(!!((n > ((1UL << 12) - sizeof(struct simple_transaction_argresp)))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/fs.h", 1965); panic("BUG!"); } while (0); } while(0);





 __asm__ __volatile__("": : :"memory");
 ar->size = n;
}
# 2005 "include/linux/fs.h"
static inline __attribute__((always_inline)) void __attribute__((format(printf, 1, 2)))
__simple_attr_check_format(const char *fmt, ...)
{

}

int simple_attr_open(struct inode *inode, struct file *file,
       u64 (*get)(void *), void (*set)(void *, u64),
       const char *fmt);
int simple_attr_close(struct inode *inode, struct file *file);
ssize_t simple_attr_read(struct file *file, char *buf,
    size_t len, loff_t *ppos);
ssize_t simple_attr_write(struct file *file, const char *buf,
     size_t len, loff_t *ppos);
# 2032 "include/linux/fs.h"
static inline __attribute__((always_inline)) char *alloc_secdata(void)
{
 return (char *)1;
}

static inline __attribute__((always_inline)) void free_secdata(void *secdata)
{ }
# 16 "include/linux/mm.h" 2

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



struct task_struct;

extern int debug_locks;
extern int debug_locks_silent;




extern int debug_locks_off(void);
# 46 "include/linux/debug_locks.h"
struct task_struct;







static inline __attribute__((always_inline)) void debug_show_all_locks(void)
{
}

static inline __attribute__((always_inline)) void debug_show_held_locks(struct task_struct *task)
{
}

static inline __attribute__((always_inline)) void
debug_check_no_locks_freed(const void *from, unsigned long len)
{
}

static inline __attribute__((always_inline)) void
debug_check_no_locks_held(struct task_struct *task)
{
}
# 18 "include/linux/mm.h" 2
# 1 "include/linux/backing-dev.h" 1
# 13 "include/linux/backing-dev.h"
struct page;




enum bdi_state {
 BDI_pdflush,
 BDI_write_congested,
 BDI_read_congested,
 BDI_unused,
};

typedef int (congested_fn)(void *, int);

struct backing_dev_info {
 unsigned long ra_pages;
 unsigned long state;
 unsigned int capabilities;
 congested_fn *congested_fn;
 void *congested_data;
 void (*unplug_io_fn)(struct backing_dev_info *, struct page *);
 void *unplug_io_data;
};
# 63 "include/linux/backing-dev.h"
extern struct backing_dev_info default_backing_dev_info;
void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);

int writeback_acquire(struct backing_dev_info *bdi);
int writeback_in_progress(struct backing_dev_info *bdi);
void writeback_release(struct backing_dev_info *bdi);

static inline __attribute__((always_inline)) int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
{
 if (bdi->congested_fn)
  return bdi->congested_fn(bdi->congested_data, bdi_bits);
 return (bdi->state & bdi_bits);
}

static inline __attribute__((always_inline)) int bdi_read_congested(struct backing_dev_info *bdi)
{
 return bdi_congested(bdi, 1 << BDI_read_congested);
}

static inline __attribute__((always_inline)) int bdi_write_congested(struct backing_dev_info *bdi)
{
 return bdi_congested(bdi, 1 << BDI_write_congested);
}

static inline __attribute__((always_inline)) int bdi_rw_congested(struct backing_dev_info *bdi)
{
 return bdi_congested(bdi, (1 << BDI_read_congested)|
      (1 << BDI_write_congested));
}

void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
void set_bdi_congested(struct backing_dev_info *bdi, int rw);
long congestion_wait(int rw, long timeout);
void congestion_end(int rw);
# 19 "include/linux/mm.h" 2
# 1 "include/linux/mm_types.h" 1
# 9 "include/linux/mm_types.h"
struct address_space;
# 18 "include/linux/mm_types.h"
struct page {
 unsigned long flags;

 atomic_t _count;
 atomic_t _mapcount;



 union {
     struct {
  unsigned long private;






  struct address_space *mapping;






     };



 };
 unsigned long index;
 struct list_head lru;
# 73 "include/linux/mm_types.h"
};
# 20 "include/linux/mm.h" 2

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 int sysctl_legacy_va_layout;





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



# 1 "include/asm-generic/4level-fixup.h" 1
# 5 "include/asm/pgtable.h" 2



typedef pte_t *pte_addr_t;
# 27 "include/asm/pgtable.h"
extern void paging_init(void);







static inline __attribute__((always_inline)) int pte_file(pte_t pte)
{
 return 0;
}







extern unsigned int kobjsize(const void *objp);
# 41 "include/linux/mm.h" 2
# 60 "include/linux/mm.h"
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;


 atomic_t vm_usage;




};






struct vm_list_struct {
 struct vm_list_struct *next;
 struct vm_area_struct *vma;
};


extern struct rb_root nommu_vma_tree;
extern struct rw_semaphore nommu_vma_sem;

extern unsigned int kobjsize(const void *objp);
# 190 "include/linux/mm.h"
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);
 unsigned long (*nopfn)(struct vm_area_struct * area, unsigned long address);
 int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);



 int (*page_mkwrite)(struct vm_area_struct *vma, struct page *page);







};

struct mmu_gather;
struct inode;
# 227 "include/linux/mm.h"
# 1 "include/linux/page-flags.h" 1
# 254 "include/linux/page-flags.h"
struct page;

int test_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);
}
# 228 "include/linux/mm.h" 2
# 251 "include/linux/mm.h"
static inline __attribute__((always_inline)) int put_page_testzero(struct page *page)
{
 do { } while(0);
 return (atomic_sub_return(1, (&page->_count)) == 0);
}





static inline __attribute__((always_inline)) int get_page_unless_zero(struct page *page)
{
 do { } while(0);
 return ({ int c, old; c = (((&page->_count))->counter); while (c != (0) && (old = ((int)((__typeof__(*(&((((&page->_count)))->counter))))__cmpxchg((&((((&page->_count)))->counter)),(unsigned long)((c)), (unsigned long)((c + (1))),sizeof(*(&((((&page->_count)))->counter))))))) != c) c = old; c != (0); });
}

static inline __attribute__((always_inline)) int page_count(struct page *page)
{
 if (__builtin_expect(!!((__builtin_constant_p(14) ? __constant_test_bit((14),(&(page)->flags)) : __test_bit((14),(&(page)->flags)))), 0))
  page = (struct page *)((page)->private);
 return ((&page->_count)->counter);
}

static inline __attribute__((always_inline)) void get_page(struct page *page)
{
 if (__builtin_expect(!!((__builtin_constant_p(14) ? __constant_test_bit((14),(&(page)->flags)) : __test_bit((14),(&(page)->flags)))), 0))
  page = (struct page *)((page)->private);
 do { } while(0);
 atomic_inc(&page->_count);
}





static inline __attribute__((always_inline)) void init_page_count(struct page *page)
{
 (((&page->_count)->counter) = 1);
}

void put_page(struct page *page);
void put_pages_list(struct list_head *pages);

void split_page(struct page *page, unsigned int order);
# 431 "include/linux/mm.h"
static inline __attribute__((always_inline)) enum zone_type page_zonenum(struct page *page)
{
 return (page->flags >> (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0))) & ((1UL << 1) - 1);
}

struct zone;
extern struct zone *zone_table[];

static inline __attribute__((always_inline)) int page_zone_id(struct page *page)
{
 return (page->flags >> (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0))) & ((1UL << (0 + 1)) - 1);
}
static inline __attribute__((always_inline)) struct zone *page_zone(struct page *page)
{
 return zone_table[page_zone_id(page)];
}

static inline __attribute__((always_inline)) unsigned long zone_to_nid(struct zone *zone)
{



 return 0;

}

static inline __attribute__((always_inline)) unsigned long page_to_nid(struct page *page)
{
 if ((0 > 0 || 0 == 0))
  return (page->flags >> ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0))) & ((1UL << 0) - 1);
 else
  return zone_to_nid(page_zone(page));
}
static inline __attribute__((always_inline)) unsigned long page_to_section(struct page *page)
{
 return (page->flags >> (((sizeof(unsigned long)*8) - 0) * (0 != 0))) & ((1UL << 0) - 1);
}

static inline __attribute__((always_inline)) void set_page_zone(struct page *page, enum zone_type zone)
{
 page->flags &= ~(((1UL << 1) - 1) << (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0)));
 page->flags |= (zone & ((1UL << 1) - 1)) << (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0));
}

static inline __attribute__((always_inline)) void set_page_node(struct page *page, unsigned long node)
{
 page->flags &= ~(((1UL << 0) - 1) << ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0)));
 page->flags |= (node & ((1UL << 0) - 1)) << ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0));
}
static inline __attribute__((always_inline)) void set_page_section(struct page *page, unsigned long section)
{
 page->flags &= ~(((1UL << 0) - 1) << (((sizeof(unsigned long)*8) - 0) * (0 != 0)));
 page->flags |= (section & ((1UL << 0) - 1)) << (((sizeof(unsigned long)*8) - 0) * (0 != 0));
}

static inline __attribute__((always_inline)) void set_page_links(struct page *page, enum zone_type zone,
 unsigned long node, unsigned long pfn)
{
 set_page_zone(page, zone);
 set_page_node(page, node);
 set_page_section(page, ((pfn) >> 0));
}




# 1 "include/linux/vmstat.h" 1
# 34 "include/linux/vmstat.h"
enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
  PGALLOC_DMA, PGALLOC_NORMAL ,
  PGFREE, PGACTIVATE, PGDEACTIVATE,
  PGFAULT, PGMAJFAULT,
  PGREFILL_DMA, PGREFILL_NORMAL ,
  PGSTEAL_DMA, PGSTEAL_NORMAL ,
  PGSCAN_KSWAPD_DMA, PGSCAN_KSWAPD_NORMAL ,
  PGSCAN_DIRECT_DMA, PGSCAN_DIRECT_NORMAL ,
  PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
  PAGEOUTRUN, ALLOCSTALL, PGROTATED,
  NR_VM_EVENT_ITEMS
};

struct vm_event_state {
 unsigned long event[NR_VM_EVENT_ITEMS];
};

extern __typeof__(struct vm_event_state) per_cpu__vm_event_states;

static inline __attribute__((always_inline)) void __count_vm_event(enum vm_event_item item)
{
 per_cpu__vm_event_states.event[item]++;
}

static inline __attribute__((always_inline)) void count_vm_event(enum vm_event_item item)
{
 (*({ extern int simple_identifier_vm_event_states(void); do { } while (0); &per_cpu__vm_event_states; })).event[item]++;
 do { } while (0);
}

static inline __attribute__((always_inline)) void __count_vm_events(enum vm_event_item item, long delta)
{
 per_cpu__vm_event_states.event[item] += delta;
}

static inline __attribute__((always_inline)) void count_vm_events(enum vm_event_item item, long delta)
{
 (*({ extern int simple_identifier_vm_event_states(void); do { } while (0); &per_cpu__vm_event_states; })).event[item] += delta;
 do { } while (0);
}

extern void all_vm_events(unsigned long *);
extern void vm_events_fold_cpu(int cpu);
# 96 "include/linux/vmstat.h"
extern atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];

static inline __attribute__((always_inline)) void zone_page_state_add(long x, struct zone *zone,
     enum zone_stat_item item)
{
 atomic_long_add(x, &zone->vm_stat[item]);
 atomic_long_add(x, &vm_stat[item]);
}

static inline __attribute__((always_inline)) unsigned long global_page_state(enum zone_stat_item item)
{
 long x = atomic_long_read(&vm_stat[item]);




 return x;
}

static inline __attribute__((always_inline)) unsigned long zone_page_state(struct zone *zone,
     enum zone_stat_item item)
{
 long x = atomic_long_read(&zone->vm_stat[item]);




 return x;
}
# 165 "include/linux/vmstat.h"
static inline __attribute__((always_inline)) void zap_zone_vm_stats(struct zone *zone)
{
 memset(zone->vm_stat, 0, sizeof(zone->vm_stat));
}

extern void inc_zone_state(struct zone *, enum zone_stat_item);
# 192 "include/linux/vmstat.h"
static inline __attribute__((always_inline)) void __mod_zone_page_state(struct zone *zone,
   enum zone_stat_item item, int delta)
{
 zone_page_state_add(delta, zone, item);
}

static inline __attribute__((always_inline)) void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
{
 atomic_long_inc(&zone->vm_stat[item]);
 atomic_long_inc(&vm_stat[item]);
}

static inline __attribute__((always_inline)) void __inc_zone_page_state(struct page *page,
   enum zone_stat_item item)
{
 __inc_zone_state(page_zone(page), item);
}

static inline __attribute__((always_inline)) void __dec_zone_page_state(struct page *page,
   enum zone_stat_item item)
{
 atomic_long_dec(&page_zone(page)->vm_stat[item]);
 atomic_long_dec(&vm_stat[item]);
}
# 225 "include/linux/vmstat.h"
static inline __attribute__((always_inline)) void refresh_cpu_vm_stats(int cpu) { }
static inline __attribute__((always_inline)) void refresh_vm_stats(void) { }
# 498 "include/linux/mm.h" 2

static inline __attribute__((always_inline)) __attribute__((always_inline)) void *lowmem_page_address(struct page *page)
{
 return ((void *) ((unsigned long)((((unsigned long) ((void *)(((((page) - mem_map) << 12) + (0x00000000))))) >> 12) << 12)));
}
# 540 "include/linux/mm.h"
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;
}
# 622 "include/linux/mm.h"
extern void show_free_areas(void);
# 634 "include/linux/mm.h"
static inline __attribute__((always_inline)) int shmem_lock(struct file *file, int lock,
        struct user_struct *user)
{
 return 0;
}

static inline __attribute__((always_inline)) int shmem_set_policy(struct vm_area_struct *vma,
       struct mempolicy *new)
{
 return 0;
}

static inline __attribute__((always_inline)) struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
       unsigned long addr)
{
 return ((void *)0);
}

struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
extern int shmem_mmap(struct file *file, struct vm_area_struct *vma);

int shmem_zero_setup(struct vm_area_struct *);


extern unsigned long shmem_get_unmapped_area(struct file *file,
          unsigned long addr,
          unsigned long len,
          unsigned long pgoff,
          unsigned long flags);


static inline __attribute__((always_inline)) int can_do_mlock(void)
{
 if (capable(14))
  return 1;
 if ((get_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 truncate_count;
};

struct page *vm_normal_page(struct vm_area_struct *, unsigned long, pte_t);
unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
  unsigned long size, struct zap_details *);
unsigned long unmap_vmas(struct mmu_gather **tlb,
  struct vm_area_struct *start_vma, unsigned long start_addr,
  unsigned long end_addr, unsigned long *nr_accounted,
  struct zap_details *);
void free_pgd_range(struct mmu_gather **tlb, unsigned long addr,
  unsigned long end, unsigned long floor, unsigned long ceiling);
void free_pgtables(struct mmu_gather **tlb, struct vm_area_struct *start_vma,
  unsigned long floor, unsigned long ceiling);
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 int vmtruncate_range(struct inode * inode, loff_t offset, loff_t end);
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);
# 729 "include/linux/mm.h"
static inline __attribute__((always_inline)) int handle_mm_fault(struct mm_struct *mm,
   struct vm_area_struct *vma, unsigned long address,
   int write_access)
{

 do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/mm.h", 734); panic("BUG!"); } while (0);
 return 0x01;
}


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);
void print_bad_pte(struct vm_area_struct *, pte_t, unsigned long);

extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
extern void do_invalidatepage(struct page *page, unsigned long offset);

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);
# 772 "include/linux/mm.h"
typedef int (*shrinker_t)(int nr_to_scan, gfp_t gfp_mask);







struct shrinker;
extern struct shrinker *set_shrinker(int, shrinker_t);
extern void remove_shrinker(struct shrinker *shrinker);







static inline __attribute__((always_inline)) int vma_wants_writenotify(struct vm_area_struct *vma)
{
 unsigned int vm_flags = vma->vm_flags;


 if ((vm_flags & (0x00000002|0x00000008)) != ((0x00000002|0x00000008)))
  return 0;


 if (vma->vm_ops && vma->vm_ops->page_mkwrite)
  return 1;


 if (((vma->vm_page_prot).pgprot) !=
     ((protection_map[vm_flags & (0x00000001|0x00000002|0x00000004|0x00000008)]).pgprot))

  return 0;


 if (vm_flags & (0x00000400|0x02000000))
  return 0;


 return vma->vm_file && vma->vm_file->f_mapping &&
  (!(((vma->vm_file->f_mapping)->backing_dev_info)->capabilities & 0x00000001));
}

extern pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl);

int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
int __pmd_alloc(struct mm_struct *mm, pgd_t *pud, unsigned long address);
int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);
# 890 "include/linux/mm.h"
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);
# 943 "include/linux/mm.h"
extern void set_dma_reserve(unsigned long new_dma_reserve);
extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long);
extern void setup_per_zone_pages_min(void);
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);
extern void zonetable_add(struct zone *zone, int nid, enum zone_type zid,
     unsigned long pfn, unsigned long size);




static inline __attribute__((always_inline)) void setup_per_cpu_pageset(void) {}



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 void unlink_file_vma(struct vm_area_struct *);
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 int may_expand_vm(struct mm_struct *mm, unsigned long npages);

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)&(~((1UL << 12)-1)))) < offset)
  goto out;
 if (!(offset & ~(~((1UL << 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 void truncate_inode_pages_range(struct address_space *,
           loff_t lstart, loff_t lend);


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


typedef enum {

 PAGE_KEEP,

 PAGE_ACTIVATE,

 PAGE_SUCCESS,

 PAGE_CLEAN,
} pageout_t;

pageout_t pageout(struct page *page, struct address_space *mapping);







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

pgprot_t vm_get_page_prot(unsigned long vm_flags);
struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
struct page *vmalloc_to_page(void *addr);
unsigned long vmalloc_to_pfn(void *addr);
int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
   unsigned long pfn, unsigned long size, pgprot_t);
int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);

struct page *follow_page(struct vm_area_struct *, unsigned long address,
   unsigned int foll_flags);






void vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
# 1119 "include/linux/mm.h"
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);



int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
   unsigned long lru_pages);
void drop_pagecache(void);
void drop_slab(void);







__attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma);
# 14 "include/asm/uaccess.h" 2







static inline __attribute__((always_inline)) void set_fs(mm_segment_t fs)
{
 current_thread_info()->addr_limit = fs;
}
# 33 "include/asm/uaccess.h"
extern int is_in_rom(unsigned long);







static inline __attribute__((always_inline)) int _access_ok(unsigned long addr, unsigned long size)
{



 extern unsigned long memory_end, physical_mem_end;
 if (addr > (addr + size))
  return 0;
 if ((((current_thread_info()->addr_limit)) == ((0x5))))
  return 1;
 if (addr >= memory_start && (addr + size) <= memory_end)
  return 1;
 if (addr >= memory_mtd_end && (addr + size) <= physical_mem_end)
  return 1;
 if (addr >= (unsigned long)__init_begin &&
     addr + size <= (unsigned long)__init_end)
  return 1;
 if (addr >= 0xFFB00000
     && addr + size <= 0xFFB00000 + 0x1000)
  return 1;

 if (addr >= 0xFFA00000 + (_etext_l1 - _stext_l1)
     && addr + size <= 0xFFA00000 + 0xC000)
  return 1;


 if (addr >= 0xFF800000 + (_ebss_l1 - _sdata_l1)
     && addr + size <= 0xFF800000 + (0x8000 - 0x4000))
  return 1;


 if (addr >= 0xFF900000
     && addr + size <= 0xFF900000 + (0x8000 - 0x4000))
  return 1;

 return 0;

}
# 93 "include/asm/uaccess.h"
struct exception_table_entry {
 unsigned long insn, fixup;
};


extern unsigned long search_exception_table(unsigned long);
# 140 "include/asm/uaccess.h"
static inline __attribute__((always_inline)) int bad_user_access_length(void)
{
 panic("bad_user_access_length");
 return -1;
}
# 223 "include/asm/uaccess.h"
static inline __attribute__((always_inline)) long copy_from_user(void *to,
      const void * from, unsigned long n)
{
 if (_access_ok((unsigned long)(from),(n)))
  memcpy(to, from, n);
 else
  return n;
 return 0;
}

static inline __attribute__((always_inline)) long copy_to_user(void *to,
    const void * from, unsigned long n)
{
 if (_access_ok((unsigned long)(to),(n)))
  memcpy(to, from, n);
 else
  return n;
 return 0;
}





static inline __attribute__((always_inline)) long strncpy_from_user(char *dst,
                                     const char *src, long count)
{
 char *tmp;
 if (!_access_ok((unsigned long)(src),(1)))
  return -14;
 strncpy(dst, src, count);
 for (tmp = dst; *tmp && count > 0; tmp++, count--) ;
 return (tmp - dst);
}






static inline __attribute__((always_inline)) long strnlen_user(const char *src, long n)
{
 return (strlen(src) + 1);
}







static inline __attribute__((always_inline)) unsigned long clear_user(void *to, unsigned long n)
{
 memset(to, 0, n);
 return 0;
}
# 48 "net/ipv4/ip_output.c" 2

# 1 "include/linux/module.h" 1
# 15 "include/linux/module.h"
# 1 "include/linux/kmod.h" 1
# 31 "include/linux/kmod.h"
extern int request_module(const char * name, ...) __attribute__ ((format (printf, 1, 2)));






struct key;
extern int call_usermodehelper_keys(char *path, char *argv[], char *envp[],
        struct key *session_keyring, int wait);

static inline __attribute__((always_inline)) int
call_usermodehelper(char *path, char **argv, char **envp, int wait)
{
 return call_usermodehelper_keys(path, argv, envp, ((void *)0), wait);
}

extern void usermodehelper_init(void);

struct file;
extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[],
        struct file **filp);
# 16 "include/linux/module.h" 2
# 1 "include/linux/elf.h" 1





# 1 "include/linux/elf-em.h" 1
# 7 "include/linux/elf.h" 2
# 1 "include/asm/elf.h" 1
# 19 "include/asm/elf.h"
typedef unsigned long elf_greg_t;


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

typedef struct user_bfinfp_struct elf_fpregset_t;
# 8 "include/linux/elf.h" 2
# 17 "include/linux/elf.h"
typedef __u32 Elf32_Addr;
typedef __u16 Elf32_Half;
typedef __u32 Elf32_Off;
typedef __s32 Elf32_Sword;
typedef __u32 Elf32_Word;


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

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

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

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

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

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

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




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

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







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

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

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


typedef struct elf64_note {
  Elf64_Word n_namesz;
  Elf64_Word n_descsz;
  Elf64_Word n_type;
} Elf64_Nhdr;



extern Elf32_Dyn _DYNAMIC [];
# 17 "include/linux/module.h" 2


# 1 "include/linux/moduleparam.h" 1
# 29 "include/linux/moduleparam.h"
struct kernel_param;


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

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

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


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


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







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


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


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


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


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


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


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


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


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


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

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



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);
# 20 "include/linux/module.h" 2
# 1 "include/asm/local.h" 1



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




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




# 1 "include/linux/smp_lock.h" 1
# 6 "include/linux/hardirq.h" 2

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





# 1 "include/asm/irq.h" 1
# 20 "include/asm/irq.h"
# 1 "include/asm/mach/irq.h" 1
# 21 "include/asm/irq.h" 2
# 56 "include/asm/irq.h"
extern void sys_free_irq(unsigned int irq, void *dev_id);

extern void ack_bad_irq(unsigned int irq);

static __inline__ __attribute__((always_inline)) int irq_canonicalize(int irq)
{
 return irq;
}
# 7 "include/asm/hardirq.h" 2

typedef struct {
 unsigned int __softirq_pending;
 unsigned int __syscall_count;
 struct task_struct *__ksoftirqd_task;
} irq_cpustat_t;

# 1 "include/linux/irq_cpustat.h" 1
# 20 "include/linux/irq_cpustat.h"
extern irq_cpustat_t irq_stat[];
# 15 "include/asm/hardirq.h" 2
# 8 "include/linux/hardirq.h" 2
# 95 "include/linux/hardirq.h"
struct task_struct;


static inline __attribute__((always_inline)) void account_system_vtime(struct task_struct *tsk)
{
}
# 129 "include/linux/hardirq.h"
extern void irq_exit(void);
# 6 "include/asm-generic/local.h" 2
# 22 "include/asm-generic/local.h"
typedef struct
{
 atomic_long_t a;
} local_t;
# 5 "include/asm/local.h" 2
# 21 "include/linux/module.h" 2

# 1 "include/asm/module.h" 1
# 12 "include/asm/module.h"
struct mod_arch_specific {
 Elf32_Shdr *text_l1;
 Elf32_Shdr *data_a_l1;
 Elf32_Shdr *bss_a_l1;
 Elf32_Shdr *data_b_l1;
 Elf32_Shdr *bss_b_l1;
};
# 23 "include/linux/module.h" 2
# 34 "include/linux/module.h"
struct kernel_symbol
{
 unsigned long value;
 const char *name;
};

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

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);
 void (*setup)(struct module *, const char *);
 int (*test)(struct module *);
 void (*free)(struct module *);
};

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;
# 165 "include/linux/module.h"
const struct exception_table_entry *search_exception_tables(unsigned long add);

struct notifier_block;




void *__symbol_get(const char *symbol);
void *__symbol_get_gpl(const char *symbol);
# 222 "include/linux/module.h"
struct module_ref
{
 local_t count;
} ;

enum module_state
{
 MODULE_STATE_LIVE,
 MODULE_STATE_COMING,
 MODULE_STATE_GOING,
};


struct module_sect_attr
{
 struct module_attribute mattr;
 char *name;
 unsigned long address;
};

struct module_sect_attrs
{
 struct attribute_group grp;
 int nsections;
 struct module_sect_attr attrs[0];
};

struct module_param_attrs;

struct module
{
 enum module_state state;


 struct list_head list;


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


 struct module_kobject mkobj;
 struct module_param_attrs *param_attrs;
 struct module_attribute *modinfo_attrs;
 const char *version;
 const char *srcversion;


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


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


 const struct kernel_symbol *unused_syms;
 unsigned int num_unused_syms;
 const unsigned long *unused_crcs;

 const struct kernel_symbol *unused_gpl_syms;
 unsigned int num_unused_gpl_syms;
 const unsigned long *unused_gpl_crcs;


 const struct kernel_symbol *gpl_future_syms;
 unsigned int num_gpl_future_syms;
 const unsigned long *gpl_future_crcs;


 unsigned int num_exentries;
 const struct exception_table_entry *extable;


 int (*init)(void);


 void *module_init;


 void *module_core;


 unsigned long init_size, core_size;


 unsigned long init_text_size, core_text_size;


 void *unwind_info;


 struct mod_arch_specific arch;


 int unsafe;

 unsigned int taints;



 struct module_ref ref[1];


 struct list_head modules_which_use_me;


 struct task_struct *waiter;


 void (*exit)(void);




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


 struct module_sect_attrs *sect_attrs;



 void *percpu;



 char *args;
};




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


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



struct module *module_get_kallsym(unsigned int symnum, unsigned long *value,
    char *type, char *name, size_t namelen);


unsigned long module_kallsyms_lookup_name(const char *name);

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

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



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

void symbol_put_addr(void *addr);



static inline __attribute__((always_inline)) void __module_get(struct module *module)
{
 if (module) {
  do { if (__builtin_expect(!!((module_refcount(module) == 0)!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/module.h", 392); panic("BUG!"); } while (0); } while(0);
  atomic_long_inc(&(&module->ref[({ do { } while (0); 0; })].count)->a);
  do { } while (0);
 }
}

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

 if (module) {
  unsigned int cpu = ({ do { } while (0); 0; });
  if (__builtin_expect(!!(module_is_live(module)), 1))
   atomic_long_inc(&(&module->ref[cpu].count)->a);
  else
   ret = 0;
  do { } while (0);
 }
 return ret;
}

static inline __attribute__((always_inline)) void module_put(struct module *module)
{
 if (module) {
  unsigned int cpu = ({ do { } while (0); 0; });
  atomic_long_dec(&(&module->ref[cpu].count)->a);

  if (__builtin_expect(!!(!module_is_live(module)), 0))
   wake_up_process(module->waiter);
  do { } while (0);
 }
}
# 459 "include/linux/module.h"
const char *module_address_lookup(unsigned long addr,
      unsigned long *symbolsize,
      unsigned long *offset,
      char **modname);


const struct exception_table_entry *search_module_extables(unsigned long addr);

int register_module_notifier(struct notifier_block * nb);
int unregister_module_notifier(struct notifier_block * nb);

extern void print_modules(void);

struct device_driver;
void module_add_driver(struct module *, struct device_driver *);
void module_remove_driver(struct device_driver *);
# 50 "net/ipv4/ip_output.c" 2







# 1 "include/linux/socket.h" 1
# 11 "include/linux/socket.h"
struct __kernel_sockaddr_storage {
 unsigned short ss_family;

 char __data[128 - sizeof(unsigned short)];


} __attribute__ ((aligned((__alignof__ (struct sockaddr *)))));



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



# 1 "include/asm/sockios.h" 1
# 5 "include/asm/socket.h" 2
# 22 "include/linux/socket.h" 2
# 1 "include/linux/sockios.h" 1
# 23 "include/linux/socket.h" 2




extern int sysctl_somaxconn;

struct seq_file;
extern void socket_seq_show(struct seq_file *seq);


typedef unsigned short sa_family_t;





struct sockaddr {
 sa_family_t sa_family;
 char sa_data[14];
};

struct linger {
 int l_onoff;
 int l_linger;
};
# 57 "include/linux/socket.h"
struct msghdr {
 void * msg_name;
 int msg_namelen;
 struct iovec * msg_iov;
 __kernel_size_t msg_iovlen;
 void * msg_control;
 __kernel_size_t msg_controllen;
 unsigned msg_flags;
};







struct cmsghdr {
 __kernel_size_t cmsg_len;
        int cmsg_level;
        int cmsg_type;
};
# 130 "include/linux/socket.h"
static inline __attribute__((always_inline)) struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,
            struct cmsghdr *__cmsg)
{
 struct cmsghdr * __ptr;

 __ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) + ( ((__cmsg->cmsg_len)+sizeof(long)-1) & ~(sizeof(long)-1) ));
 if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
  return (struct cmsghdr *)0;

 return __ptr;
}

static inline __attribute__((always_inline)) struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)
{
 return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
}







struct ucred {
 __u32 pid;
 __u32 uid;
 __u32 gid;
};
# 289 "include/linux/socket.h"
extern int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
extern int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov,
    int offset, int len);
extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
       struct iovec *iov,
       int offset,
       unsigned int len, int *csump);

extern int verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode);
extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
extern int move_addr_to_user(void *kaddr, int klen, void *uaddr, int *ulen);
extern int move_addr_to_kernel(void *uaddr, int ulen, void *kaddr);
extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
# 58 "net/ipv4/ip_output.c" 2

# 1 "include/linux/in.h" 1
# 25 "include/linux/in.h"
enum {
  IPPROTO_IP = 0,
  IPPROTO_ICMP = 1,
  IPPROTO_IGMP = 2,
  IPPROTO_IPIP = 4,
  IPPROTO_TCP = 6,
  IPPROTO_EGP = 8,
  IPPROTO_PUP = 12,
  IPPROTO_UDP = 17,
  IPPROTO_IDP = 22,
  IPPROTO_DCCP = 33,
  IPPROTO_RSVP = 46,
  IPPROTO_GRE = 47,

  IPPROTO_IPV6 = 41,

  IPPROTO_ESP = 50,
  IPPROTO_AH = 51,
  IPPROTO_BEETPH = 94,
  IPPROTO_PIM = 103,

  IPPROTO_COMP = 108,
  IPPROTO_SCTP = 132,

  IPPROTO_RAW = 255,
  IPPROTO_MAX
};



struct in_addr {
 __be32 s_addr;
};
# 113 "include/linux/in.h"
struct ip_mreq
{
 struct in_addr imr_multiaddr;
 struct in_addr imr_interface;
};

struct ip_mreqn
{
 struct in_addr imr_multiaddr;
 struct in_addr imr_address;
 int imr_ifindex;
};

struct ip_mreq_source {
 __be32 imr_multiaddr;
 __be32 imr_interface;
 __be32 imr_sourceaddr;
};

struct ip_msfilter {
 __be32 imsf_multiaddr;
 __be32 imsf_interface;
 __u32 imsf_fmode;
 __u32 imsf_numsrc;
 __be32 imsf_slist[1];
};





struct group_req
{
 __u32 gr_interface;
 struct __kernel_sockaddr_storage gr_group;
};

struct group_source_req
{
 __u32 gsr_interface;
 struct __kernel_sockaddr_storage gsr_group;
 struct __kernel_sockaddr_storage gsr_source;
};

struct group_filter
{
 __u32 gf_interface;
 struct __kernel_sockaddr_storage gf_group;
 __u32 gf_fmode;
 __u32 gf_numsrc;
 struct __kernel_sockaddr_storage gf_slist[1];
};





struct in_pktinfo
{
 int ipi_ifindex;
 struct in_addr ipi_spec_dst;
 struct in_addr ipi_addr;
};



struct sockaddr_in {
  sa_family_t sin_family;
  __be16 sin_port;
  struct in_addr sin_addr;


  unsigned char __pad[16 - sizeof(short int) -
   sizeof(unsigned short int) - sizeof(struct in_addr)];
};
# 60 "net/ipv4/ip_output.c" 2
# 1 "include/linux/inet.h" 1
# 48 "include/linux/inet.h"
extern __be32 in_aton(const char *str);
extern int in4_pton(const char *src, int srclen, u8 *dst, char delim, const char **end);
extern int in6_pton(const char *src, int srclen, u8 *dst, char delim, const char **end);
# 61 "net/ipv4/ip_output.c" 2
# 1 "include/linux/netdevice.h" 1
# 28 "include/linux/netdevice.h"
# 1 "include/linux/if.h" 1
# 27 "include/linux/if.h"
# 1 "include/linux/hdlc/ioctl.h" 1
# 37 "include/linux/hdlc/ioctl.h"
typedef struct {
 unsigned int clock_rate;
 unsigned int clock_type;
 unsigned short loopback;
} sync_serial_settings;

typedef struct {
 unsigned int clock_rate;
 unsigned int clock_type;
 unsigned short loopback;
 unsigned int slot_map;
} te1_settings;

typedef struct {
 unsigned short encoding;
 unsigned short parity;
} raw_hdlc_proto;

typedef struct {
 unsigned int t391;
 unsigned int t392;
 unsigned int n391;
 unsigned int n392;
 unsigned int n393;
 unsigned short lmi;
 unsigned short dce;
} fr_proto;

typedef struct {
 unsigned int dlci;
} fr_proto_pvc;

typedef struct {
 unsigned int dlci;
 char master[16];
}fr_proto_pvc_info;

typedef struct {
    unsigned int interval;
    unsigned int timeout;
} cisco_proto;
# 28 "include/linux/if.h" 2
# 93 "include/linux/if.h"
enum {
 IF_OPER_UNKNOWN,
 IF_OPER_NOTPRESENT,
 IF_OPER_DOWN,
 IF_OPER_LOWERLAYERDOWN,
 IF_OPER_TESTING,
 IF_OPER_DORMANT,
 IF_OPER_UP,
};


enum {
 IF_LINK_MODE_DEFAULT,
 IF_LINK_MODE_DORMANT,
};
# 119 "include/linux/if.h"
struct ifmap
{
 unsigned long mem_start;
 unsigned long mem_end;
 unsigned short base_addr;
 unsigned char irq;
 unsigned char dma;
 unsigned char port;

};

struct if_settings
{
 unsigned int type;
 unsigned int size;
 union {

  raw_hdlc_proto *raw_hdlc;
  cisco_proto *cisco;
  fr_proto *fr;
  fr_proto_pvc *fr_pvc;
  fr_proto_pvc_info *fr_pvc_info;


  sync_serial_settings *sync;
  te1_settings *te1;
 } ifs_ifsu;
};
# 155 "include/linux/if.h"
struct ifreq
{

 union
 {
  char ifrn_name[16];
 } ifr_ifrn;

 union {
  struct sockaddr ifru_addr;
  struct sockaddr ifru_dstaddr;
  struct sockaddr ifru_broadaddr;
  struct sockaddr ifru_netmask;
  struct sockaddr ifru_hwaddr;
  short ifru_flags;
  int ifru_ivalue;
  int ifru_mtu;
  struct ifmap ifru_map;
  char ifru_slave[16];
  char ifru_newname[16];
  void * ifru_data;
  struct if_settings ifru_settings;
 } ifr_ifru;
};
# 205 "include/linux/if.h"
struct ifconf
{
 int ifc_len;
 union
 {
  char *ifcu_buf;
  struct ifreq *ifcu_req;
 } ifc_ifcu;
};
# 29 "include/linux/netdevice.h" 2
# 1 "include/linux/if_ether.h" 1
# 104 "include/linux/if_ether.h"
struct ethhdr {
 unsigned char h_dest[6];
 unsigned char h_source[6];
 __be16 h_proto;
} __attribute__((packed));


# 1 "include/linux/skbuff.h" 1
# 26 "include/linux/skbuff.h"
# 1 "include/linux/highmem.h" 1






# 1 "include/asm/cacheflush.h" 1
# 34 "include/asm/cacheflush.h"
# 1 "include/asm/cplb.h" 1
# 35 "include/asm/cacheflush.h" 2

extern void blackfin_icache_dcache_flush_range(unsigned int, unsigned int);
extern void blackfin_icache_flush_range(unsigned int, unsigned int);
extern void blackfin_dcache_flush_range(unsigned int, unsigned int);
extern void blackfin_dcache_invalidate_range(unsigned int, unsigned int);
extern void blackfin_dflush_page(void *);
# 50 "include/asm/cacheflush.h"
static inline __attribute__((always_inline)) void flush_icache_range(unsigned start, unsigned end)
{



 blackfin_icache_flush_range((start), (end));
# 70 "include/asm/cacheflush.h"
}
# 8 "include/linux/highmem.h" 2


static inline __attribute__((always_inline)) void flush_anon_page(struct page *page, unsigned long vmaddr)
{
}



static inline __attribute__((always_inline)) void flush_kernel_dcache_page(struct page *page)
{
}
# 31 "include/linux/highmem.h"
static inline __attribute__((always_inline)) unsigned int nr_free_highpages(void) { return 0; }




static inline __attribute__((always_inline)) void *kmap(struct page *page)
{
 do { do { } while (0); } while (0);
 return lowmem_page_address(page);
}
# 53 "include/linux/highmem.h"
static inline __attribute__((always_inline)) void clear_user_highpage(struct page *page, unsigned long vaddr)
{
 void *addr = lowmem_page_address(page);
 memset((addr), 0, (1UL << 12));
 do { } while (0);

 __asm__ __volatile__("": : :"memory");
}


static inline __attribute__((always_inline)) struct page *
alloc_zeroed_user_highpage(struct vm_area_struct *vma, unsigned long vaddr)
{
 struct page *page = alloc_pages_node(((0)), ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u) | (( gfp_t)0x20000u) | (( gfp_t)0x02u)), 0);

 if (page)
  clear_user_highpage(page, vaddr);

 return page;
}


static inline __attribute__((always_inline)) void clear_highpage(struct page *page)
{
 void *kaddr = lowmem_page_address(page);
 memset((kaddr), 0, (1UL << 12));
 do { } while (0);
}




static inline __attribute__((always_inline)) void memclear_highpage_flush(struct page *page, unsigned int offset, unsigned int size)
{
 void *kaddr;

 do { if (__builtin_expect(!!((offset + size > (1UL << 12))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/highmem.h", 89); panic("BUG!"); } while (0); } while(0);

 kaddr = lowmem_page_address(page);
 memset((char *)kaddr + offset, 0, size);
 do { } while (0);
 do { } while (0);
}

static inline __attribute__((always_inline)) void copy_user_highpage(struct page *to, struct page *from, unsigned long vaddr)
{
 char *vfrom, *vto;

 vfrom = lowmem_page_address(from);
 vto = lowmem_page_address(to);
 memcpy((vto), (vfrom), (1UL << 12));
 do { } while (0);
 do { } while (0);

 __asm__ __volatile__("": : :"memory");
}

static inline __attribute__((always_inline)) void copy_highpage(struct page *to, struct page *from)
{
 char *vfrom, *vto;

 vfrom = lowmem_page_address(from);
 vto = lowmem_page_address(to);
 memcpy((vto), (vfrom), (1UL << 12));
 do { } while (0);
 do { } while (0);
}
# 27 "include/linux/skbuff.h" 2
# 1 "include/linux/poll.h" 1



# 1 "include/asm/poll.h" 1
# 18 "include/asm/poll.h"
struct pollfd {
 int fd;
 short events;
 short revents;
};
# 5 "include/linux/poll.h" 2
# 23 "include/linux/poll.h"
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_table_entry {
 struct file * filp;
 wait_queue_t wait;
 wait_queue_head_t * wait_address;
};




struct poll_wqueues {
 poll_table pt;
 struct poll_table_page * table;
 int error;
 int inline_index;
 struct poll_table_entry inline_entries[((832 - 256) / sizeof(struct poll_table_entry))];
};

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;
# 87 "include/linux/poll.h"
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)
  return copy_from_user(fdset, ufdset, nr) ? -14 : 0;

 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, s64 *timeout);
extern int do_sys_poll(struct pollfd * ufds, unsigned int nfds,
         s64 *timeout);
# 28 "include/linux/skbuff.h" 2
# 1 "include/linux/net.h" 1
# 24 "include/linux/net.h"
struct poll_table_struct;
struct inode;
# 47 "include/linux/net.h"
typedef enum {
 SS_FREE = 0,
 SS_UNCONNECTED,
 SS_CONNECTING,
 SS_CONNECTED,
 SS_DISCONNECTING
} socket_state;





# 1 "include/linux/random.h" 1
# 35 "include/linux/random.h"
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_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport);
extern u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr,
          __u16 dport);
extern __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
     __u16 sport, __u16 dport);
extern __u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr,
       __u16 sport, __u16 dport);
extern u64 secure_dccp_sequence_number(__u32 saddr, __u32 daddr,
           __u16 sport, __u16 dport);


extern struct file_operations random_fops, urandom_fops;


unsigned int get_random_int(void);
unsigned long randomize_range(unsigned long start, unsigned long end, unsigned long len);

u32 random32(void);
void srandom32(u32 seed);
# 60 "include/linux/net.h" 2
# 83 "include/linux/net.h"
enum sock_type {
 SOCK_STREAM = 1,
 SOCK_DGRAM = 2,
 SOCK_RAW = 3,
 SOCK_RDM = 4,
 SOCK_SEQPACKET = 5,
 SOCK_DCCP = 6,
 SOCK_PACKET = 10,
};
# 108 "include/linux/net.h"
struct socket {
 socket_state state;
 unsigned long flags;
 const struct proto_ops *ops;
 struct fasync_struct *fasync_list;
 struct file *file;
 struct sock *sk;
 wait_queue_head_t wait;
 short type;
};

struct vm_area_struct;
struct page;
struct kiocb;
struct sockaddr;
struct msghdr;
struct module;

struct proto_ops {
 int family;
 struct module *owner;
 int (*release) (struct socket *sock);
 int (*bind) (struct socket *sock,
          struct sockaddr *myaddr,
          int sockaddr_len);
 int (*connect) (struct socket *sock,
          struct sockaddr *vaddr,
          int sockaddr_len, int flags);
 int (*socketpair)(struct socket *sock1,
          struct socket *sock2);
 int (*accept) (struct socket *sock,
          struct socket *newsock, int flags);
 int (*getname) (struct socket *sock,
          struct sockaddr *addr,
          int *sockaddr_len, int peer);
 unsigned int (*poll) (struct file *file, struct socket *sock,
          struct poll_table_struct *wait);
 int (*ioctl) (struct socket *sock, unsigned int cmd,
          unsigned long arg);
 int (*compat_ioctl) (struct socket *sock, unsigned int cmd,
          unsigned long arg);
 int (*listen) (struct socket *sock, int len);
 int (*shutdown) (struct socket *sock, int flags);
 int (*setsockopt)(struct socket *sock, int level,
          int optname, char *optval, int optlen);
 int (*getsockopt)(struct socket *sock, int level,
          int optname, char *optval, int *optlen);
 int (*compat_setsockopt)(struct socket *sock, int level,
          int optname, char *optval, int optlen);
 int (*compat_getsockopt)(struct socket *sock, int level,
          int optname, char *optval, int *optlen);
 int (*sendmsg) (struct kiocb *iocb, struct socket *sock,
          struct msghdr *m, size_t total_len);
 int (*recvmsg) (struct kiocb *iocb, struct socket *sock,
          struct msghdr *m, size_t total_len,
          int flags);
 int (*mmap) (struct file *file, struct socket *sock,
          struct vm_area_struct * vma);
 ssize_t (*sendpage) (struct socket *sock, struct page *page,
          int offset, size_t size, int flags);
};

struct net_proto_family {
 int family;
 int (*create)(struct socket *sock, int protocol);
 struct module *owner;
};

struct iovec;
struct kvec;

extern int sock_wake_async(struct socket *sk, int how, int band);
extern int sock_register(const struct net_proto_family *fam);
extern void sock_unregister(int family);
extern int sock_create(int family, int type, int proto,
     struct socket **res);
extern int sock_create_kern(int family, int type, int proto,
          struct socket **res);
extern int sock_create_lite(int family, int type, int proto,
          struct socket **res);
extern void sock_release(struct socket *sock);
extern int sock_sendmsg(struct socket *sock, struct msghdr *msg,
      size_t len);
extern int sock_recvmsg(struct socket *sock, struct msghdr *msg,
      size_t size, int flags);
extern int sock_map_fd(struct socket *sock);
extern struct socket *sockfd_lookup(int fd, int *err);

extern int net_ratelimit(void);




extern int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
        struct kvec *vec, size_t num, size_t len);
extern int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
        struct kvec *vec, size_t num,
        size_t len, int flags);

extern int kernel_bind(struct socket *sock, struct sockaddr *addr,
         int addrlen);
extern int kernel_listen(struct socket *sock, int backlog);
extern int kernel_accept(struct socket *sock, struct socket **newsock,
    int flags);
extern int kernel_connect(struct socket *sock, struct sockaddr *addr,
     int addrlen, int flags);
extern int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
         int *addrlen);
extern int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
         int *addrlen);
extern int kernel_getsockopt(struct socket *sock, int level, int optname,
        char *optval, int *optlen);
extern int kernel_setsockopt(struct socket *sock, int level, int optname,
        char *optval, int optlen);
extern int kernel_sendpage(struct socket *sock, struct page *page, int offset,
      size_t size, int flags);
extern int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg);
# 316 "include/linux/net.h"
# 1 "include/linux/sysctl.h" 1
# 32 "include/linux/sysctl.h"
struct file;
struct completion;






struct __sysctl_args {
 int *name;
 int nlen;
 void *oldval;
 size_t *oldlenp;
 void *newval;
 size_t newlen;
 unsigned long __unused[4];
};
# 61 "include/linux/sysctl.h"
enum
{
 CTL_KERN=1,
 CTL_VM=2,
 CTL_NET=3,

 CTL_FS=5,
 CTL_DEBUG=6,
 CTL_DEV=7,
 CTL_BUS=8,
 CTL_ABI=9,
 CTL_CPU=10
};


enum
{
 CTL_BUS_ISA=1
};


enum
{
 INOTIFY_MAX_USER_INSTANCES=1,
 INOTIFY_MAX_USER_WATCHES=2,
 INOTIFY_MAX_QUEUED_EVENTS=3
};


enum
{
 KERN_OSTYPE=1,
 KERN_OSRELEASE=2,
 KERN_OSREV=3,
 KERN_VERSION=4,
 KERN_SECUREMASK=5,
 KERN_PROF=6,
 KERN_NODENAME=7,
 KERN_DOMAINNAME=8,

 KERN_CAP_BSET=14,
 KERN_PANIC=15,
 KERN_REALROOTDEV=16,

 KERN_SPARC_REBOOT=21,
 KERN_CTLALTDEL=22,
 KERN_PRINTK=23,
 KERN_NAMETRANS=24,
 KERN_PPC_HTABRECLAIM=25,
 KERN_PPC_ZEROPAGED=26,
 KERN_PPC_POWERSAVE_NAP=27,
 KERN_MODPROBE=28,
 KERN_SG_BIG_BUFF=29,
 KERN_ACCT=30,
 KERN_PPC_L2CR=31,

 KERN_RTSIGNR=32,
 KERN_RTSIGMAX=33,

 KERN_SHMMAX=34,
 KERN_MSGMAX=35,
 KERN_MSGMNB=36,
 KERN_MSGPOOL=37,
 KERN_SYSRQ=38,
 KERN_MAX_THREADS=39,
  KERN_RANDOM=40,
  KERN_SHMALL=41,
  KERN_MSGMNI=42,
  KERN_SEM=43,
  KERN_SPARC_STOP_A=44,
  KERN_SHMMNI=45,
 KERN_OVERFLOWUID=46,
 KERN_OVERFLOWGID=47,
 KERN_SHMPATH=48,
 KERN_HOTPLUG=49,
 KERN_IEEE_EMULATION_WARNINGS=50,
 KERN_S390_USER_DEBUG_LOGGING=51,
 KERN_CORE_USES_PID=52,
 KERN_TAINTED=53,
 KERN_CADPID=54,
 KERN_PIDMAX=55,
   KERN_CORE_PATTERN=56,
 KERN_PANIC_ON_OOPS=57,
 KERN_HPPA_PWRSW=58,
 KERN_HPPA_UNALIGNED=59,
 KERN_PRINTK_RATELIMIT=60,
 KERN_PRINTK_RATELIMIT_BURST=61,
 KERN_PTY=62,
 KERN_NGROUPS_MAX=63,
 KERN_SPARC_SCONS_PWROFF=64,
 KERN_HZ_TIMER=65,
 KERN_UNKNOWN_NMI_PANIC=66,
 KERN_BOOTLOADER_TYPE=67,
 KERN_RANDOMIZE=68,
 KERN_SETUID_DUMPABLE=69,
 KERN_SPIN_RETRY=70,
 KERN_ACPI_VIDEO_FLAGS=71,
 KERN_IA64_UNALIGNED=72,
 KERN_COMPAT_LOG=73,
 KERN_MAX_LOCK_DEPTH=74,
 KERN_NMI_WATCHDOG=75,
 KERN_PANIC_ON_NMI=76,
};




enum
{
 VM_UNUSED1=1,
 VM_UNUSED2=2,
 VM_UNUSED3=3,
 VM_UNUSED4=4,
 VM_OVERCOMMIT_MEMORY=5,
 VM_UNUSED5=6,
 VM_UNUSED7=7,
 VM_UNUSED8=8,
 VM_UNUSED9=9,
 VM_PAGE_CLUSTER=10,
 VM_DIRTY_BACKGROUND=11,
 VM_DIRTY_RATIO=12,
 VM_DIRTY_WB_CS=13,
 VM_DIRTY_EXPIRE_CS=14,
 VM_NR_PDFLUSH_THREADS=15,
 VM_OVERCOMMIT_RATIO=16,
 VM_PAGEBUF=17,
 VM_HUGETLB_PAGES=18,
 VM_SWAPPINESS=19,
 VM_LOWMEM_RESERVE_RATIO=20,
 VM_MIN_FREE_KBYTES=21,
 VM_MAX_MAP_COUNT=22,
 VM_LAPTOP_MODE=23,
 VM_BLOCK_DUMP=24,
 VM_HUGETLB_GROUP=25,
 VM_VFS_CACHE_PRESSURE=26,
 VM_LEGACY_VA_LAYOUT=27,
 VM_SWAP_TOKEN_TIMEOUT=28,
 VM_DROP_PAGECACHE=29,
 VM_PERCPU_PAGELIST_FRACTION=30,
 VM_ZONE_RECLAIM_MODE=31,
 VM_MIN_UNMAPPED=32,
 VM_PANIC_ON_OOM=33,
 VM_VDSO_ENABLED=34,
 VM_MIN_SLAB=35,
};



enum
{
 NET_CORE=1,
 NET_ETHER=2,
 NET_802=3,
 NET_UNIX=4,
 NET_IPV4=5,
 NET_IPX=6,
 NET_ATALK=7,
 NET_NETROM=8,
 NET_AX25=9,
 NET_BRIDGE=10,
 NET_ROSE=11,
 NET_IPV6=12,
 NET_X25=13,
 NET_TR=14,
 NET_DECNET=15,
 NET_ECONET=16,
 NET_SCTP=17,
 NET_LLC=18,
 NET_NETFILTER=19,
 NET_DCCP=20,
};


enum
{
 RANDOM_POOLSIZE=1,
 RANDOM_ENTROPY_COUNT=2,
 RANDOM_READ_THRESH=3,
 RANDOM_WRITE_THRESH=4,
 RANDOM_BOOT_ID=5,
 RANDOM_UUID=6
};


enum
{
 PTY_MAX=1,
 PTY_NR=2
};


enum
{
 BUS_ISA_MEM_BASE=1,
 BUS_ISA_PORT_BASE=2,
 BUS_ISA_PORT_SHIFT=3
};


enum
{
 NET_CORE_WMEM_MAX=1,
 NET_CORE_RMEM_MAX=2,
 NET_CORE_WMEM_DEFAULT=3,
 NET_CORE_RMEM_DEFAULT=4,

 NET_CORE_MAX_BACKLOG=6,
 NET_CORE_FASTROUTE=7,
 NET_CORE_MSG_COST=8,
 NET_CORE_MSG_BURST=9,
 NET_CORE_OPTMEM_MAX=10,
 NET_CORE_HOT_LIST_LENGTH=11,
 NET_CORE_DIVERT_VERSION=12,
 NET_CORE_NO_CONG_THRESH=13,
 NET_CORE_NO_CONG=14,
 NET_CORE_LO_CONG=15,
 NET_CORE_MOD_CONG=16,
 NET_CORE_DEV_WEIGHT=17,
 NET_CORE_SOMAXCONN=18,
 NET_CORE_BUDGET=19,
 NET_CORE_AEVENT_ETIME=20,
 NET_CORE_AEVENT_RSEQTH=21,
};







enum
{
 NET_UNIX_DESTROY_DELAY=1,
 NET_UNIX_DELETE_DELAY=2,
 NET_UNIX_MAX_DGRAM_QLEN=3,
};


enum
{
 NET_NF_CONNTRACK_MAX=1,
 NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT=2,
 NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV=3,
 NET_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED=4,
 NET_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT=5,
 NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT=6,
 NET_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK=7,
 NET_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT=8,
 NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE=9,
 NET_NF_CONNTRACK_UDP_TIMEOUT=10,
 NET_NF_CONNTRACK_UDP_TIMEOUT_STREAM=11,
 NET_NF_CONNTRACK_ICMP_TIMEOUT=12,
 NET_NF_CONNTRACK_GENERIC_TIMEOUT=13,
 NET_NF_CONNTRACK_BUCKETS=14,
 NET_NF_CONNTRACK_LOG_INVALID=15,
 NET_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS=16,
 NET_NF_CONNTRACK_TCP_LOOSE=17,
 NET_NF_CONNTRACK_TCP_BE_LIBERAL=18,
 NET_NF_CONNTRACK_TCP_MAX_RETRANS=19,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED=20,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT=21,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED=22,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED=23,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT=24,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD=25,
 NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT=26,
 NET_NF_CONNTRACK_COUNT=27,
 NET_NF_CONNTRACK_ICMPV6_TIMEOUT=28,
 NET_NF_CONNTRACK_FRAG6_TIMEOUT=29,
 NET_NF_CONNTRACK_FRAG6_LOW_THRESH=30,
 NET_NF_CONNTRACK_FRAG6_HIGH_THRESH=31,
 NET_NF_CONNTRACK_CHECKSUM=32,
};


enum
{

 NET_IPV4_FORWARD=8,
 NET_IPV4_DYNADDR=9,

 NET_IPV4_CONF=16,
 NET_IPV4_NEIGH=17,
 NET_IPV4_ROUTE=18,
 NET_IPV4_FIB_HASH=19,
 NET_IPV4_NETFILTER=20,

 NET_IPV4_TCP_TIMESTAMPS=33,
 NET_IPV4_TCP_WINDOW_SCALING=34,
 NET_IPV4_TCP_SACK=35,
 NET_IPV4_TCP_RETRANS_COLLAPSE=36,
 NET_IPV4_DEFAULT_TTL=37,
 NET_IPV4_AUTOCONFIG=38,
 NET_IPV4_NO_PMTU_DISC=39,
 NET_IPV4_TCP_SYN_RETRIES=40,
 NET_IPV4_IPFRAG_HIGH_THRESH=41,
 NET_IPV4_IPFRAG_LOW_THRESH=42,
 NET_IPV4_IPFRAG_TIME=43,
 NET_IPV4_TCP_MAX_KA_PROBES=44,
 NET_IPV4_TCP_KEEPALIVE_TIME=45,
 NET_IPV4_TCP_KEEPALIVE_PROBES=46,
 NET_IPV4_TCP_RETRIES1=47,
 NET_IPV4_TCP_RETRIES2=48,
 NET_IPV4_TCP_FIN_TIMEOUT=49,
 NET_IPV4_IP_MASQ_DEBUG=50,
 NET_TCP_SYNCOOKIES=51,
 NET_TCP_STDURG=52,
 NET_TCP_RFC1337=53,
 NET_TCP_SYN_TAILDROP=54,
 NET_TCP_MAX_SYN_BACKLOG=55,
 NET_IPV4_LOCAL_PORT_RANGE=56,
 NET_IPV4_ICMP_ECHO_IGNORE_ALL=57,
 NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS=58,
 NET_IPV4_ICMP_SOURCEQUENCH_RATE=59,
 NET_IPV4_ICMP_DESTUNREACH_RATE=60,
 NET_IPV4_ICMP_TIMEEXCEED_RATE=61,
 NET_IPV4_ICMP_PARAMPROB_RATE=62,
 NET_IPV4_ICMP_ECHOREPLY_RATE=63,
 NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES=64,
 NET_IPV4_IGMP_MAX_MEMBERSHIPS=65,
 NET_TCP_TW_RECYCLE=66,
 NET_IPV4_ALWAYS_DEFRAG=67,
 NET_IPV4_TCP_KEEPALIVE_INTVL=68,
 NET_IPV4_INET_PEER_THRESHOLD=69,
 NET_IPV4_INET_PEER_MINTTL=70,
 NET_IPV4_INET_PEER_MAXTTL=71,
 NET_IPV4_INET_PEER_GC_MINTIME=72,
 NET_IPV4_INET_PEER_GC_MAXTIME=73,
 NET_TCP_ORPHAN_RETRIES=74,
 NET_TCP_ABORT_ON_OVERFLOW=75,
 NET_TCP_SYNACK_RETRIES=76,
 NET_TCP_MAX_ORPHANS=77,
 NET_TCP_MAX_TW_BUCKETS=78,
 NET_TCP_FACK=79,
 NET_TCP_REORDERING=80,
 NET_TCP_ECN=81,
 NET_TCP_DSACK=82,
 NET_TCP_MEM=83,
 NET_TCP_WMEM=84,
 NET_TCP_RMEM=85,
 NET_TCP_APP_WIN=86,
 NET_TCP_ADV_WIN_SCALE=87,
 NET_IPV4_NONLOCAL_BIND=88,
 NET_IPV4_ICMP_RATELIMIT=89,
 NET_IPV4_ICMP_RATEMASK=90,
 NET_TCP_TW_REUSE=91,
 NET_TCP_FRTO=92,
 NET_TCP_LOW_LATENCY=93,
 NET_IPV4_IPFRAG_SECRET_INTERVAL=94,
 NET_IPV4_IGMP_MAX_MSF=96,
 NET_TCP_NO_METRICS_SAVE=97,
 NET_TCP_DEFAULT_WIN_SCALE=105,
 NET_TCP_MODERATE_RCVBUF=106,
 NET_TCP_TSO_WIN_DIVISOR=107,
 NET_TCP_BIC_BETA=108,
 NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109,
 NET_TCP_CONG_CONTROL=110,
 NET_TCP_ABC=111,
 NET_IPV4_IPFRAG_MAX_DIST=112,
  NET_TCP_MTU_PROBING=113,
 NET_TCP_BASE_MSS=114,
 NET_IPV4_TCP_WORKAROUND_SIGNED_WINDOWS=115,
 NET_TCP_DMA_COPYBREAK=116,
 NET_TCP_SLOW_START_AFTER_IDLE=117,
 NET_CIPSOV4_CACHE_ENABLE=118,
 NET_CIPSOV4_CACHE_BUCKET_SIZE=119,
 NET_CIPSOV4_RBM_OPTFMT=120,
 NET_CIPSOV4_RBM_STRICTVALID=121,
};

enum {
 NET_IPV4_ROUTE_FLUSH=1,
 NET_IPV4_ROUTE_MIN_DELAY=2,
 NET_IPV4_ROUTE_MAX_DELAY=3,
 NET_IPV4_ROUTE_GC_THRESH=4,
 NET_IPV4_ROUTE_MAX_SIZE=5,
 NET_IPV4_ROUTE_GC_MIN_INTERVAL=6,
 NET_IPV4_ROUTE_GC_TIMEOUT=7,
 NET_IPV4_ROUTE_GC_INTERVAL=8,
 NET_IPV4_ROUTE_REDIRECT_LOAD=9,
 NET_IPV4_ROUTE_REDIRECT_NUMBER=10,
 NET_IPV4_ROUTE_REDIRECT_SILENCE=11,
 NET_IPV4_ROUTE_ERROR_COST=12,
 NET_IPV4_ROUTE_ERROR_BURST=13,
 NET_IPV4_ROUTE_GC_ELASTICITY=14,
 NET_IPV4_ROUTE_MTU_EXPIRES=15,
 NET_IPV4_ROUTE_MIN_PMTU=16,
 NET_IPV4_ROUTE_MIN_ADVMSS=17,
 NET_IPV4_ROUTE_SECRET_INTERVAL=18,
 NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS=19,
};

enum
{
 NET_PROTO_CONF_ALL=-2,
 NET_PROTO_CONF_DEFAULT=-3


};

enum
{
 NET_IPV4_CONF_FORWARDING=1,
 NET_IPV4_CONF_MC_FORWARDING=2,
 NET_IPV4_CONF_PROXY_ARP=3,
 NET_IPV4_CONF_ACCEPT_REDIRECTS=4,
 NET_IPV4_CONF_SECURE_REDIRECTS=5,
 NET_IPV4_CONF_SEND_REDIRECTS=6,
 NET_IPV4_CONF_SHARED_MEDIA=7,
 NET_IPV4_CONF_RP_FILTER=8,
 NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE=9,
 NET_IPV4_CONF_BOOTP_RELAY=10,
 NET_IPV4_CONF_LOG_MARTIANS=11,
 NET_IPV4_CONF_TAG=12,
 NET_IPV4_CONF_ARPFILTER=13,
 NET_IPV4_CONF_MEDIUM_ID=14,
 NET_IPV4_CONF_NOXFRM=15,
 NET_IPV4_CONF_NOPOLICY=16,
 NET_IPV4_CONF_FORCE_IGMP_VERSION=17,
 NET_IPV4_CONF_ARP_ANNOUNCE=18,
 NET_IPV4_CONF_ARP_IGNORE=19,
 NET_IPV4_CONF_PROMOTE_SECONDARIES=20,
 NET_IPV4_CONF_ARP_ACCEPT=21,
 __NET_IPV4_CONF_MAX
};


enum
{
 NET_IPV4_NF_CONNTRACK_MAX=1,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT=2,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV=3,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED=4,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT=5,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT=6,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK=7,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT=8,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE=9,
 NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT=10,
 NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT_STREAM=11,
 NET_IPV4_NF_CONNTRACK_ICMP_TIMEOUT=12,
 NET_IPV4_NF_CONNTRACK_GENERIC_TIMEOUT=13,
 NET_IPV4_NF_CONNTRACK_BUCKETS=14,
 NET_IPV4_NF_CONNTRACK_LOG_INVALID=15,
 NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS=16,
 NET_IPV4_NF_CONNTRACK_TCP_LOOSE=17,
 NET_IPV4_NF_CONNTRACK_TCP_BE_LIBERAL=18,
 NET_IPV4_NF_CONNTRACK_TCP_MAX_RETRANS=19,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED=20,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT=21,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED=22,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED=23,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT=24,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD=25,
  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT=26,
 NET_IPV4_NF_CONNTRACK_COUNT=27,
 NET_IPV4_NF_CONNTRACK_CHECKSUM=28,
};


enum {
 NET_IPV6_CONF=16,
 NET_IPV6_NEIGH=17,
 NET_IPV6_ROUTE=18,
 NET_IPV6_ICMP=19,
 NET_IPV6_BINDV6ONLY=20,
 NET_IPV6_IP6FRAG_HIGH_THRESH=21,
 NET_IPV6_IP6FRAG_LOW_THRESH=22,
 NET_IPV6_IP6FRAG_TIME=23,
 NET_IPV6_IP6FRAG_SECRET_INTERVAL=24,
 NET_IPV6_MLD_MAX_MSF=25,
};

enum {
 NET_IPV6_ROUTE_FLUSH=1,
 NET_IPV6_ROUTE_GC_THRESH=2,
 NET_IPV6_ROUTE_MAX_SIZE=3,
 NET_IPV6_ROUTE_GC_MIN_INTERVAL=4,
 NET_IPV6_ROUTE_GC_TIMEOUT=5,
 NET_IPV6_ROUTE_GC_INTERVAL=6,
 NET_IPV6_ROUTE_GC_ELASTICITY=7,
 NET_IPV6_ROUTE_MTU_EXPIRES=8,
 NET_IPV6_ROUTE_MIN_ADVMSS=9,
 NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS=10
};

enum {
 NET_IPV6_FORWARDING=1,
 NET_IPV6_HOP_LIMIT=2,
 NET_IPV6_MTU=3,
 NET_IPV6_ACCEPT_RA=4,
 NET_IPV6_ACCEPT_REDIRECTS=5,
 NET_IPV6_AUTOCONF=6,
 NET_IPV6_DAD_TRANSMITS=7,
 NET_IPV6_RTR_SOLICITS=8,
 NET_IPV6_RTR_SOLICIT_INTERVAL=9,
 NET_IPV6_RTR_SOLICIT_DELAY=10,
 NET_IPV6_USE_TEMPADDR=11,
 NET_IPV6_TEMP_VALID_LFT=12,
 NET_IPV6_TEMP_PREFERED_LFT=13,
 NET_IPV6_REGEN_MAX_RETRY=14,
 NET_IPV6_MAX_DESYNC_FACTOR=15,
 NET_IPV6_MAX_ADDRESSES=16,
 NET_IPV6_FORCE_MLD_VERSION=17,
 NET_IPV6_ACCEPT_RA_DEFRTR=18,
 NET_IPV6_ACCEPT_RA_PINFO=19,
 NET_IPV6_ACCEPT_RA_RTR_PREF=20,
 NET_IPV6_RTR_PROBE_INTERVAL=21,
 NET_IPV6_ACCEPT_RA_RT_INFO_MAX_PLEN=22,
 NET_IPV6_PROXY_NDP=23,
 __NET_IPV6_MAX
};


enum {
 NET_IPV6_ICMP_RATELIMIT=1
};


enum {
 NET_NEIGH_MCAST_SOLICIT=1,
 NET_NEIGH_UCAST_SOLICIT=2,
 NET_NEIGH_APP_SOLICIT=3,
 NET_NEIGH_RETRANS_TIME=4,
 NET_NEIGH_REACHABLE_TIME=5,
 NET_NEIGH_DELAY_PROBE_TIME=6,
 NET_NEIGH_GC_STALE_TIME=7,
 NET_NEIGH_UNRES_QLEN=8,
 NET_NEIGH_PROXY_QLEN=9,
 NET_NEIGH_ANYCAST_DELAY=10,
 NET_NEIGH_PROXY_DELAY=11,
 NET_NEIGH_LOCKTIME=12,
 NET_NEIGH_GC_INTERVAL=13,
 NET_NEIGH_GC_THRESH1=14,
 NET_NEIGH_GC_THRESH2=15,
 NET_NEIGH_GC_THRESH3=16,
 NET_NEIGH_RETRANS_TIME_MS=17,
 NET_NEIGH_REACHABLE_TIME_MS=18,
 __NET_NEIGH_MAX
};


enum {
 NET_DCCP_DEFAULT=1,
};


enum {
 NET_DCCP_DEFAULT_SEQ_WINDOW = 1,
 NET_DCCP_DEFAULT_RX_CCID = 2,
 NET_DCCP_DEFAULT_TX_CCID = 3,
 NET_DCCP_DEFAULT_ACK_RATIO = 4,
 NET_DCCP_DEFAULT_SEND_ACKVEC = 5,
 NET_DCCP_DEFAULT_SEND_NDP = 6,
};


enum {
 NET_IPX_PPROP_BROADCASTING=1,
 NET_IPX_FORWARDING=2
};


enum {
 NET_LLC2=1,
 NET_LLC_STATION=2,
};


enum {
 NET_LLC2_TIMEOUT=1,
};


enum {
 NET_LLC_STATION_ACK_TIMEOUT=1,
};


enum {
 NET_LLC2_ACK_TIMEOUT=1,
 NET_LLC2_P_TIMEOUT=2,
 NET_LLC2_REJ_TIMEOUT=3,
 NET_LLC2_BUSY_TIMEOUT=4,
};


enum {
 NET_ATALK_AARP_EXPIRY_TIME=1,
 NET_ATALK_AARP_TICK_TIME=2,
 NET_ATALK_AARP_RETRANSMIT_LIMIT=3,
 NET_ATALK_AARP_RESOLVE_TIME=4
};



enum {
 NET_NETROM_DEFAULT_PATH_QUALITY=1,
 NET_NETROM_OBSOLESCENCE_COUNT_INITIALISER=2,
 NET_NETROM_NETWORK_TTL_INITIALISER=3,
 NET_NETROM_TRANSPORT_TIMEOUT=4,
 NET_NETROM_TRANSPORT_MAXIMUM_TRIES=5,
 NET_NETROM_TRANSPORT_ACKNOWLEDGE_DELAY=6,
 NET_NETROM_TRANSPORT_BUSY_DELAY=7,
 NET_NETROM_TRANSPORT_REQUESTED_WINDOW_SIZE=8,
 NET_NETROM_TRANSPORT_NO_ACTIVITY_TIMEOUT=9,
 NET_NETROM_ROUTING_CONTROL=10,
 NET_NETROM_LINK_FAILS_COUNT=11,
 NET_NETROM_RESET=12
};


enum {
 NET_AX25_IP_DEFAULT_MODE=1,
 NET_AX25_DEFAULT_MODE=2,
 NET_AX25_BACKOFF_TYPE=3,
 NET_AX25_CONNECT_MODE=4,
 NET_AX25_STANDARD_WINDOW=5,
 NET_AX25_EXTENDED_WINDOW=6,
 NET_AX25_T1_TIMEOUT=7,
 NET_AX25_T2_TIMEOUT=8,
 NET_AX25_T3_TIMEOUT=9,
 NET_AX25_IDLE_TIMEOUT=10,
 NET_AX25_N2=11,
 NET_AX25_PACLEN=12,
 NET_AX25_PROTOCOL=13,
 NET_AX25_DAMA_SLAVE_TIMEOUT=14
};


enum {
 NET_ROSE_RESTART_REQUEST_TIMEOUT=1,
 NET_ROSE_CALL_REQUEST_TIMEOUT=2,
 NET_ROSE_RESET_REQUEST_TIMEOUT=3,
 NET_ROSE_CLEAR_REQUEST_TIMEOUT=4,
 NET_ROSE_ACK_HOLD_BACK_TIMEOUT=5,
 NET_ROSE_ROUTING_CONTROL=6,
 NET_ROSE_LINK_FAIL_TIMEOUT=7,
 NET_ROSE_MAX_VCS=8,
 NET_ROSE_WINDOW_SIZE=9,
 NET_ROSE_NO_ACTIVITY_TIMEOUT=10
};


enum {
 NET_X25_RESTART_REQUEST_TIMEOUT=1,
 NET_X25_CALL_REQUEST_TIMEOUT=2,
 NET_X25_RESET_REQUEST_TIMEOUT=3,
 NET_X25_CLEAR_REQUEST_TIMEOUT=4,
 NET_X25_ACK_HOLD_BACK_TIMEOUT=5
};


enum
{
 NET_TR_RIF_TIMEOUT=1
};


enum {
 NET_DECNET_NODE_TYPE = 1,
 NET_DECNET_NODE_ADDRESS = 2,
 NET_DECNET_NODE_NAME = 3,
 NET_DECNET_DEFAULT_DEVICE = 4,
 NET_DECNET_TIME_WAIT = 5,
 NET_DECNET_DN_COUNT = 6,
 NET_DECNET_DI_COUNT = 7,
 NET_DECNET_DR_COUNT = 8,
 NET_DECNET_DST_GC_INTERVAL = 9,
 NET_DECNET_CONF = 10,
 NET_DECNET_NO_FC_MAX_CWND = 11,
 NET_DECNET_MEM = 12,
 NET_DECNET_RMEM = 13,
 NET_DECNET_WMEM = 14,
 NET_DECNET_DEBUG_LEVEL = 255
};


enum {
 NET_DECNET_CONF_LOOPBACK = -2,
 NET_DECNET_CONF_DDCMP = -3,
 NET_DECNET_CONF_PPP = -4,
 NET_DECNET_CONF_X25 = -5,
 NET_DECNET_CONF_GRE = -6,
 NET_DECNET_CONF_ETHER = -7


};


enum {
 NET_DECNET_CONF_DEV_PRIORITY = 1,
 NET_DECNET_CONF_DEV_T1 = 2,
 NET_DECNET_CONF_DEV_T2 = 3,
 NET_DECNET_CONF_DEV_T3 = 4,
 NET_DECNET_CONF_DEV_FORWARDING = 5,
 NET_DECNET_CONF_DEV_BLKSIZE = 6,
 NET_DECNET_CONF_DEV_STATE = 7
};


enum {
 NET_SCTP_RTO_INITIAL = 1,
 NET_SCTP_RTO_MIN = 2,
 NET_SCTP_RTO_MAX = 3,
 NET_SCTP_RTO_ALPHA = 4,
 NET_SCTP_RTO_BETA = 5,
 NET_SCTP_VALID_COOKIE_LIFE = 6,
 NET_SCTP_ASSOCIATION_MAX_RETRANS = 7,
 NET_SCTP_PATH_MAX_RETRANS = 8,
 NET_SCTP_MAX_INIT_RETRANSMITS = 9,
 NET_SCTP_HB_INTERVAL = 10,
 NET_SCTP_PRESERVE_ENABLE = 11,
 NET_SCTP_MAX_BURST = 12,
 NET_SCTP_ADDIP_ENABLE = 13,
 NET_SCTP_PRSCTP_ENABLE = 14,
 NET_SCTP_SNDBUF_POLICY = 15,
 NET_SCTP_SACK_TIMEOUT = 16,
 NET_SCTP_RCVBUF_POLICY = 17,
};


enum {
 NET_BRIDGE_NF_CALL_ARPTABLES = 1,
 NET_BRIDGE_NF_CALL_IPTABLES = 2,
 NET_BRIDGE_NF_CALL_IP6TABLES = 3,
 NET_BRIDGE_NF_FILTER_VLAN_TAGGED = 4,
};


enum
{
 FS_NRINODE=1,
 FS_STATINODE=2,
 FS_MAXINODE=3,
 FS_NRDQUOT=4,
 FS_MAXDQUOT=5,
 FS_NRFILE=6,
 FS_MAXFILE=7,
 FS_DENTRY=8,
 FS_NRSUPER=9,
 FS_MAXSUPER=10,
 FS_OVERFLOWUID=11,
 FS_OVERFLOWGID=12,
 FS_LEASES=13,
 FS_DIR_NOTIFY=14,
 FS_LEASE_TIME=15,
 FS_DQSTATS=16,
 FS_XFS=17,
 FS_AIO_NR=18,
 FS_AIO_MAX_NR=19,
 FS_INOTIFY=20,
};


enum {
 FS_DQ_LOOKUPS = 1,
 FS_DQ_DROPS = 2,
 FS_DQ_READS = 3,
 FS_DQ_WRITES = 4,
 FS_DQ_CACHE_HITS = 5,
 FS_DQ_ALLOCATED = 6,
 FS_DQ_FREE = 7,
 FS_DQ_SYNCS = 8,
 FS_DQ_WARNINGS = 9,
};




enum {
 DEV_CDROM=1,
 DEV_HWMON=2,
 DEV_PARPORT=3,
 DEV_RAID=4,
 DEV_MAC_HID=5,
 DEV_SCSI=6,
 DEV_IPMI=7,
};


enum {
 DEV_CDROM_INFO=1,
 DEV_CDROM_AUTOCLOSE=2,
 DEV_CDROM_AUTOEJECT=3,
 DEV_CDROM_DEBUG=4,
 DEV_CDROM_LOCK=5,
 DEV_CDROM_CHECK_MEDIA=6
};


enum {
 DEV_PARPORT_DEFAULT=-3
};


enum {
 DEV_RAID_SPEED_LIMIT_MIN=1,
 DEV_RAID_SPEED_LIMIT_MAX=2
};


enum {
 DEV_PARPORT_DEFAULT_TIMESLICE=1,
 DEV_PARPORT_DEFAULT_SPINTIME=2
};


enum {
 DEV_PARPORT_SPINTIME=1,
 DEV_PARPORT_BASE_ADDR=2,
 DEV_PARPORT_IRQ=3,
 DEV_PARPORT_DMA=4,
 DEV_PARPORT_MODES=5,
 DEV_PARPORT_DEVICES=6,
 DEV_PARPORT_AUTOPROBE=16
};


enum {
 DEV_PARPORT_DEVICES_ACTIVE=-3,
};


enum {
 DEV_PARPORT_DEVICE_TIMESLICE=1,
};


enum {
 DEV_MAC_HID_KEYBOARD_SENDS_LINUX_KEYCODES=1,
 DEV_MAC_HID_KEYBOARD_LOCK_KEYCODES=2,
 DEV_MAC_HID_MOUSE_BUTTON_EMULATION=3,
 DEV_MAC_HID_MOUSE_BUTTON2_KEYCODE=4,
 DEV_MAC_HID_MOUSE_BUTTON3_KEYCODE=5,
 DEV_MAC_HID_ADB_MOUSE_SENDS_KEYCODES=6
};


enum {
 DEV_SCSI_LOGGING_LEVEL=1,
};


enum {
 DEV_IPMI_POWEROFF_POWERCYCLE=1,
};


enum
{
 ABI_DEFHANDLER_COFF=1,
 ABI_DEFHANDLER_ELF=2,
 ABI_DEFHANDLER_LCALL7=3,
 ABI_DEFHANDLER_LIBCSO=4,
 ABI_TRACE=5,
 ABI_FAKE_UTSNAME=6,
};




extern void sysctl_init(void);

typedef struct ctl_table ctl_table;

typedef int ctl_handler (ctl_table *table, int *name, int nlen,
    void *oldval, size_t *oldlenp,
    void *newval, size_t newlen,
    void **context);

typedef int proc_handler (ctl_table *ctl, int write, struct file * filp,
     void *buffer, size_t *lenp, loff_t *ppos);

extern int proc_dostring(ctl_table *, int, struct file *,
    void *, size_t *, loff_t *);
extern int proc_dointvec(ctl_table *, int, struct file *,
    void *, size_t *, loff_t *);
extern int proc_dointvec_bset(ctl_table *, int, struct file *,
         void *, size_t *, loff_t *);
extern int proc_dointvec_minmax(ctl_table *, int, struct file *,
    void *, size_t *, loff_t *);
extern int proc_dointvec_jiffies(ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
extern int proc_dointvec_userhz_jiffies(ctl_table *, int, struct file *,
     void *, size_t *, loff_t *);
extern int proc_dointvec_ms_jiffies(ctl_table *, int, struct file *,
        void *, size_t *, loff_t *);
extern int proc_doulongvec_minmax(ctl_table *, int, struct file *,
      void *, size_t *, loff_t *);
extern int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int,
          struct file *, void *, size_t *, loff_t *);

extern int do_sysctl (int *name, int nlen,
        void *oldval, size_t *oldlenp,
        void *newval, size_t newlen);

extern int do_sysctl_strategy (ctl_table *table,
          int *name, int nlen,
          void *oldval, size_t *oldlenp,
          void *newval, size_t newlen, void ** context);

extern ctl_handler sysctl_string;
extern ctl_handler sysctl_intvec;
extern ctl_handler sysctl_jiffies;
extern ctl_handler sysctl_ms_jiffies;
# 1010 "include/linux/sysctl.h"
struct ctl_table
{
 int ctl_name;
 const char *procname;
 void *data;
 int maxlen;
 mode_t mode;
 ctl_table *child;
 proc_handler *proc_handler;
 ctl_handler *strategy;
 struct proc_dir_entry *de;
 void *extra1;
 void *extra2;
};



struct ctl_table_header
{
 ctl_table *ctl_table;
 struct list_head ctl_entry;
 int used;
 struct completion *unregistering;
};

struct ctl_table_header * register_sysctl_table(ctl_table * table,
      int insert_at_head);
void unregister_sysctl_table(struct ctl_table_header * table);
# 317 "include/linux/net.h" 2
extern ctl_table net_table[];
extern int net_msg_cost;
extern int net_msg_burst;
# 29 "include/linux/skbuff.h" 2
# 1 "include/linux/textsearch.h" 1
# 13 "include/linux/textsearch.h"
struct ts_config;
# 25 "include/linux/textsearch.h"
struct ts_state
{
 unsigned int offset;
 char cb[40];
};
# 41 "include/linux/textsearch.h"
struct ts_ops
{
 const char *name;
 struct ts_config * (*init)(const void *, unsigned int, gfp_t);
 unsigned int (*find)(struct ts_config *,
     struct ts_state *);
 void (*destroy)(struct ts_config *);
 void * (*get_pattern)(struct ts_config *);
 unsigned int (*get_pattern_len)(struct ts_config *);
 struct module *owner;
 struct list_head list;
};







struct ts_config
{
 struct ts_ops *ops;
# 76 "include/linux/textsearch.h"
 unsigned int (*get_next_block)(unsigned int consumed,
        const u8 **dst,
        struct ts_config *conf,
        struct ts_state *state);
# 89 "include/linux/textsearch.h"
 void (*finish)(struct ts_config *conf,
       struct ts_state *state);
};
# 105 "include/linux/textsearch.h"
static inline __attribute__((always_inline)) unsigned int textsearch_next(struct ts_config *conf,
        struct ts_state *state)
{
 unsigned int ret = conf->ops->find(conf, state);

 if (conf->finish)
  conf->finish(conf, state);

 return ret;
}
# 124 "include/linux/textsearch.h"
static inline __attribute__((always_inline)) unsigned int textsearch_find(struct ts_config *conf,
        struct ts_state *state)
{
 state->offset = 0;
 return textsearch_next(conf, state);
}





static inline __attribute__((always_inline)) void *textsearch_get_pattern(struct ts_config *conf)
{
 return conf->ops->get_pattern(conf);
}





static inline __attribute__((always_inline)) unsigned int textsearch_get_pattern_len(struct ts_config *conf)
{
 return conf->ops->get_pattern_len(conf);
}

extern int textsearch_register(struct ts_ops *);
extern int textsearch_unregister(struct ts_ops *);
extern struct ts_config *textsearch_prepare(const char *, const void *,
         unsigned int, gfp_t, int);
extern void textsearch_destroy(struct ts_config *conf);
extern unsigned int textsearch_find_continuous(struct ts_config *,
            struct ts_state *,
            const void *, unsigned int);





static inline __attribute__((always_inline)) struct ts_config *alloc_ts_config(size_t payload,
      gfp_t gfp_mask)
{
 struct ts_config *conf;

 conf = kmalloc((((sizeof(*conf)) + 8 -1) & ~(8 -1)) + payload, gfp_mask);
 if (conf == ((void *)0))
  return ERR_PTR(-12);

 memset(conf, 0, (((sizeof(*conf)) + 8 -1) & ~(8 -1)) + payload);
 return conf;
}

static inline __attribute__((always_inline)) void *ts_config_priv(struct ts_config *conf)
{
 return ((u8 *) conf + (((sizeof(struct ts_config)) + 8 -1) & ~(8 -1)));
}
# 30 "include/linux/skbuff.h" 2
# 1 "include/net/checksum.h" 1
# 26 "include/net/checksum.h"
# 1 "include/asm/checksum.h" 1
# 18 "include/asm/checksum.h"
unsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum);
# 28 "include/asm/checksum.h"
unsigned int csum_partial_copy(const unsigned char *src, unsigned char *dst,
          int len, int sum);
# 38 "include/asm/checksum.h"
extern unsigned int csum_partial_copy_from_user(const unsigned char *src,
      unsigned char *dst, int len,
      int sum, int *csum_err);




unsigned short ip_fast_csum(unsigned char *iph, unsigned int ihl);





static inline __attribute__((always_inline)) unsigned int csum_fold(unsigned int sum)
{
 while (sum >> 16)
  sum = (sum & 0xffff) + (sum >> 16);
 return ((~(sum << 16)) >> 16);
}






static inline __attribute__((always_inline)) unsigned int
csum_tcpudp_nofold(unsigned long saddr, unsigned long daddr, unsigned short len,
     unsigned short proto, unsigned int sum)
{

 __asm__ ("%0 = %0 + %1;\n\t"
   "CC = AC0;\n\t"
   "if !CC jump 4;\n\t"
   "%0 = %0 + %4;\n\t"
   "%0 = %0 + %2;\n\t"
   "CC = AC0;\n\t"
                 "if !CC jump 4;\n\t"
                 "%0 = %0 + %4;\n\t"
    "%0 = %0 + %3;\n\t"
   "CC = AC0;\n\t"
                 "if !CC jump 4;\n\t"
                 "%0 = %0 + %4;\n\t"
                 "NOP;\n\t"
    : "=d" (sum)
   : "d" (daddr), "d" (saddr), "d" ((ntohs(len)<<16)+proto*256), "d" (1), "0"(sum));

 return (sum);
}

static inline __attribute__((always_inline)) unsigned short int
csum_tcpudp_magic(unsigned long saddr, unsigned long daddr, unsigned short len,
    unsigned short proto, unsigned int sum)
{
 return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
}






extern unsigned short ip_compute_csum(const unsigned char *buff, int len);
# 27 "include/net/checksum.h" 2


static inline __attribute__((always_inline))
unsigned int csum_and_copy_from_user (const unsigned char *src, unsigned char *dst,
          int len, int sum, int *err_ptr)
{
 if (_access_ok((unsigned long)(src),(len)))
  return csum_partial_copy_from_user(src, dst, len, sum, err_ptr);

 if (len)
  *err_ptr = -14;

 return sum;
}



static __inline__ __attribute__((always_inline)) unsigned int csum_and_copy_to_user
(const unsigned char *src, unsigned char *dst, int len, unsigned int sum, int *err_ptr)
{
 sum = csum_partial(src, len, sum);

 if (_access_ok((unsigned long)(dst),(len))) {
  if (copy_to_user(dst, src, len) == 0)
   return sum;
 }
 if (len)
  *err_ptr = -14;

 return -1;
}


static inline __attribute__((always_inline)) unsigned int csum_add(unsigned int csum, unsigned int addend)
{
 csum += addend;
 return csum + (csum < addend);
}

static inline __attribute__((always_inline)) unsigned int csum_sub(unsigned int csum, unsigned int addend)
{
 return csum_add(csum, ~addend);
}

static inline __attribute__((always_inline)) unsigned int
csum_block_add(unsigned int csum, unsigned int csum2, int offset)
{
 if (offset&1)
  csum2 = ((csum2&0xFF00FF)<<8)+((csum2>>8)&0xFF00FF);
 return csum_add(csum, csum2);
}

static inline __attribute__((always_inline)) unsigned int
csum_block_sub(unsigned int csum, unsigned int csum2, int offset)
{
 if (offset&1)
  csum2 = ((csum2&0xFF00FF)<<8)+((csum2>>8)&0xFF00FF);
 return csum_sub(csum, csum2);
}
# 31 "include/linux/skbuff.h" 2
# 1 "include/linux/dmaengine.h" 1
# 32 "include/linux/skbuff.h" 2
# 87 "include/linux/skbuff.h"
struct net_device;
# 110 "include/linux/skbuff.h"
struct sk_buff_head {

 struct sk_buff *next;
 struct sk_buff *prev;

 __u32 qlen;
 spinlock_t lock;
};

struct sk_buff;




typedef struct skb_frag_struct skb_frag_t;

struct skb_frag_struct {
 struct page *page;
 __u16 page_offset;
 __u16 size;
};




struct skb_shared_info {
 atomic_t dataref;
 unsigned short nr_frags;
 unsigned short gso_size;

 unsigned short gso_segs;
 unsigned short gso_type;
 unsigned int ip6_frag_id;
 struct sk_buff *frag_list;
 skb_frag_t frags[(65536/(1UL << 12) + 2)];
};
# 161 "include/linux/skbuff.h"
struct skb_timeval {
 u32 off_sec;
 u32 off_usec;
};


enum {
 SKB_FCLONE_UNAVAILABLE,
 SKB_FCLONE_ORIG,
 SKB_FCLONE_CLONE,
};

enum {
 SKB_GSO_TCPV4 = 1 << 0,
 SKB_GSO_UDP = 1 << 1,


 SKB_GSO_DODGY = 1 << 2,


 SKB_GSO_TCP_ECN = 1 << 3,

 SKB_GSO_TCPV6 = 1 << 4,
};
# 232 "include/linux/skbuff.h"
struct sk_buff {

 struct sk_buff *next;
 struct sk_buff *prev;

 struct sock *sk;
 struct skb_timeval tstamp;
 struct net_device *dev;
 struct net_device *input_dev;

 union {
  struct tcphdr *th;
  struct udphdr *uh;
  struct icmphdr *icmph;
  struct igmphdr *igmph;
  struct iphdr *ipiph;
  struct ipv6hdr *ipv6h;
  unsigned char *raw;
 } h;

 union {
  struct iphdr *iph;
  struct ipv6hdr *ipv6h;
  struct arphdr *arph;
  unsigned char *raw;
 } nh;

 union {
    unsigned char *raw;
 } mac;

 struct dst_entry *dst;
 struct sec_path *sp;







 char cb[48];

 unsigned int len,
    data_len,
    mac_len,
    csum;
 __u32 priority;
 __u8 local_df:1,
    cloned:1,
    ip_summed:2,
    nohdr:1,
    nfctinfo:3;
 __u8 pkt_type:3,
    fclone:2,
    ipvs_property:1;
 __be16 protocol;

 void (*destructor)(struct sk_buff *skb);
# 315 "include/linux/skbuff.h"
 unsigned int truesize;
 atomic_t users;
 unsigned char *head,
    *data,
    *tail,
    *end;
};
# 331 "include/linux/skbuff.h"
extern void kfree_skb(struct sk_buff *skb);
extern void __kfree_skb(struct sk_buff *skb);
extern struct sk_buff *__alloc_skb(unsigned int size,
       gfp_t priority, int fclone);
static inline __attribute__((always_inline)) struct sk_buff *alloc_skb(unsigned int size,
     gfp_t priority)
{
 return __alloc_skb(size, priority, 0);
}

static inline __attribute__((always_inline)) struct sk_buff *alloc_skb_fclone(unsigned int size,
            gfp_t priority)
{
 return __alloc_skb(size, priority, 1);
}

extern struct sk_buff *alloc_skb_from_cache(kmem_cache_t *cp,
         unsigned int size,
         gfp_t priority);
extern void kfree_skbmem(struct sk_buff *skb);
extern struct sk_buff *skb_clone(struct sk_buff *skb,
     gfp_t priority);
extern struct sk_buff *skb_copy(const struct sk_buff *skb,
    gfp_t priority);
extern struct sk_buff *pskb_copy(struct sk_buff *skb,
     gfp_t gfp_mask);
extern int pskb_expand_head(struct sk_buff *skb,
     int nhead, int ntail,
     gfp_t gfp_mask);
extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
         unsigned int headroom);
extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
           int newheadroom, int newtailroom,
           gfp_t priority);
extern int skb_pad(struct sk_buff *skb, int pad);

extern void skb_over_panic(struct sk_buff *skb, int len,
         void *here);
extern void skb_under_panic(struct sk_buff *skb, int len,
          void *here);
extern void skb_truesize_bug(struct sk_buff *skb);

static inline __attribute__((always_inline)) void skb_truesize_check(struct sk_buff *skb)
{
 if (__builtin_expect(!!((int)skb->truesize < sizeof(struct sk_buff) + skb->len), 0))
  skb_truesize_bug(skb);
}

extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
   int getfrag(void *from, char *to, int offset,
   int len,int odd, struct sk_buff *skb),
   void *from, int length);

struct skb_seq_state
{
 __u32 lower_offset;
 __u32 upper_offset;
 __u32 frag_idx;
 __u32 stepped_offset;
 struct sk_buff *root_skb;
 struct sk_buff *cur_skb;
 __u8 *frag_data;
};

extern void skb_prepare_seq_read(struct sk_buff *skb,
        unsigned int from, unsigned int to,
        struct skb_seq_state *st);
extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
       struct skb_seq_state *st);
extern void skb_abort_seq_read(struct skb_seq_state *st);

extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
        unsigned int to, struct ts_config *config,
        struct ts_state *state);
# 415 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_queue_empty(const struct sk_buff_head *list)
{
 return list->next == (struct sk_buff *)list;
}
# 427 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *skb_get(struct sk_buff *skb)
{
 atomic_inc(&skb->users);
 return skb;
}
# 446 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_cloned(const struct sk_buff *skb)
{
 return skb->cloned &&
        (((&((struct skb_shared_info *)((skb)->end))->dataref)->counter) & ((1 << 16) - 1)) != 1;
}
# 459 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_header_cloned(const struct sk_buff *skb)
{
 int dataref;

 if (!skb->cloned)
  return 0;

 dataref = ((&((struct skb_shared_info *)((skb)->end))->dataref)->counter);
 dataref = (dataref & ((1 << 16) - 1)) - (dataref >> 16);
 return dataref != 1;
}
# 479 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_header_release(struct sk_buff *skb)
{
 do { if (__builtin_expect(!!((skb->nohdr)!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/skbuff.h", 481); panic("BUG!"); } while (0); } while(0);
 skb->nohdr = 1;
 atomic_add(1 << 16, &((struct skb_shared_info *)((skb)->end))->dataref);
}
# 493 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_shared(const struct sk_buff *skb)
{
 return ((&skb->users)->counter) != 1;
}
# 511 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *skb_share_check(struct sk_buff *skb,
           gfp_t pri)
{
 do { if (pri & (( gfp_t)0x10u)) do { do { } while (0); } while (0); } while (0);
 if (skb_shared(skb)) {
  struct sk_buff *nskb = skb_clone(skb, pri);
  kfree_skb(skb);
  skb = nskb;
 }
 return skb;
}
# 543 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *skb_unshare(struct sk_buff *skb,
       gfp_t pri)
{
 do { if (pri & (( gfp_t)0x10u)) do { do { } while (0); } while (0); } while (0);
 if (skb_cloned(skb)) {
  struct sk_buff *nskb = skb_copy(skb, pri);
  kfree_skb(skb);
  skb = nskb;
 }
 return skb;
}
# 568 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *skb_peek(struct sk_buff_head *list_)
{
 struct sk_buff *list = ((struct sk_buff *)list_)->next;
 if (list == (struct sk_buff *)list_)
  list = ((void *)0);
 return list;
}
# 589 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
{
 struct sk_buff *list = ((struct sk_buff *)list_)->prev;
 if (list == (struct sk_buff *)list_)
  list = ((void *)0);
 return list;
}







static inline __attribute__((always_inline)) __u32 skb_queue_len(const struct sk_buff_head *list_)
{
 return list_->qlen;
}
# 616 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_queue_head_init(struct sk_buff_head *list)
{
 do { *(&list->lock) = (spinlock_t) { .raw_lock = { }, }; } while (0);
 list->prev = list->next = (struct sk_buff *)list;
 list->qlen = 0;
}
# 641 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void __skb_queue_after(struct sk_buff_head *list,
         struct sk_buff *prev,
         struct sk_buff *newsk)
{
 struct sk_buff *next;
 list->qlen++;

 next = prev->next;
 newsk->next = next;
 newsk->prev = prev;
 next->prev = prev->next = newsk;
}
# 664 "include/linux/skbuff.h"
extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
static inline __attribute__((always_inline)) void __skb_queue_head(struct sk_buff_head *list,
        struct sk_buff *newsk)
{
 __skb_queue_after(list, (struct sk_buff *)list, newsk);
}
# 681 "include/linux/skbuff.h"
extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
static inline __attribute__((always_inline)) void __skb_queue_tail(struct sk_buff_head *list,
       struct sk_buff *newsk)
{
 struct sk_buff *prev, *next;

 list->qlen++;
 next = (struct sk_buff *)list;
 prev = next->prev;
 newsk->next = next;
 newsk->prev = prev;
 next->prev = prev->next = newsk;
}
# 704 "include/linux/skbuff.h"
extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
static inline __attribute__((always_inline)) struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
{
 struct sk_buff *next, *prev, *result;

 prev = (struct sk_buff *) list;
 next = prev->next;
 result = ((void *)0);
 if (next != prev) {
  result = next;
  next = next->next;
  list->qlen--;
  next->prev = prev;
  prev->next = next;
  result->next = result->prev = ((void *)0);
 }
 return result;
}





extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
static inline __attribute__((always_inline)) void __skb_insert(struct sk_buff *newsk,
    struct sk_buff *prev, struct sk_buff *next,
    struct sk_buff_head *list)
{
 newsk->next = next;
 newsk->prev = prev;
 next->prev = prev->next = newsk;
 list->qlen++;
}




extern void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
static inline __attribute__((always_inline)) void __skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
{
 __skb_insert(newsk, old, old->next, list);
}





extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
static inline __attribute__((always_inline)) void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
{
 struct sk_buff *next, *prev;

 list->qlen--;
 next = skb->next;
 prev = skb->prev;
 skb->next = skb->prev = ((void *)0);
 next->prev = prev;
 prev->next = next;
}
# 775 "include/linux/skbuff.h"
extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
static inline __attribute__((always_inline)) struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
{
 struct sk_buff *skb = skb_peek_tail(list);
 if (skb)
  __skb_unlink(skb, list);
 return skb;
}


static inline __attribute__((always_inline)) int skb_is_nonlinear(const struct sk_buff *skb)
{
 return skb->data_len;
}

static inline __attribute__((always_inline)) unsigned int skb_headlen(const struct sk_buff *skb)
{
 return skb->len - skb->data_len;
}

static inline __attribute__((always_inline)) int skb_pagelen(const struct sk_buff *skb)
{
 int i, len = 0;

 for (i = (int)((struct skb_shared_info *)((skb)->end))->nr_frags - 1; i >= 0; i--)
  len += ((struct skb_shared_info *)((skb)->end))->frags[i].size;
 return len + skb_headlen(skb);
}

static inline __attribute__((always_inline)) void skb_fill_page_desc(struct sk_buff *skb, int i,
          struct page *page, int off, int size)
{
 skb_frag_t *frag = &((struct skb_shared_info *)((skb)->end))->frags[i];

 frag->page = page;
 frag->page_offset = off;
 frag->size = size;
 ((struct skb_shared_info *)((skb)->end))->nr_frags = i + 1;
}
# 822 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
{
 unsigned char *tmp = skb->tail;
 do { if (__builtin_expect(!!((skb_is_nonlinear(skb))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/skbuff.h", 825); panic("BUG!"); } while (0); } while(0);
 skb->tail += len;
 skb->len += len;
 return tmp;
}
# 840 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
{
 unsigned char *tmp = skb->tail;
 do { if (__builtin_expect(!!((skb_is_nonlinear(skb))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/skbuff.h", 843); panic("BUG!"); } while (0); } while(0);
 skb->tail += len;
 skb->len += len;
 if (__builtin_expect(!!(skb->tail>skb->end), 0))
  skb_over_panic(skb, len, ({ __label__ _l; _l: &&_l;}));
 return tmp;
}

static inline __attribute__((always_inline)) unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
{
 skb->data -= len;
 skb->len += len;
 return skb->data;
}
# 867 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
{
 skb->data -= len;
 skb->len += len;
 if (__builtin_expect(!!(skb->data<skb->head), 0))
  skb_under_panic(skb, len, ({ __label__ _l; _l: &&_l;}));
 return skb->data;
}

static inline __attribute__((always_inline)) unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
{
 skb->len -= len;
 do { if (__builtin_expect(!!((skb->len < skb->data_len)!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/skbuff.h", 879); panic("BUG!"); } while (0); } while(0);
 return skb->data += len;
}
# 893 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
{
 return __builtin_expect(!!(len > skb->len), 0) ? ((void *)0) : __skb_pull(skb, len);
}

extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);

static inline __attribute__((always_inline)) unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
{
 if (len > skb_headlen(skb) &&
     !__pskb_pull_tail(skb, len-skb_headlen(skb)))
  return ((void *)0);
 skb->len -= len;
 return skb->data += len;
}

static inline __attribute__((always_inline)) unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
{
 return __builtin_expect(!!(len > skb->len), 0) ? ((void *)0) : __pskb_pull(skb, len);
}

static inline __attribute__((always_inline)) int pskb_may_pull(struct sk_buff *skb, unsigned int len)
{
 if (__builtin_expect(!!(len <= skb_headlen(skb)), 1))
  return 1;
 if (__builtin_expect(!!(len > skb->len), 0))
  return 0;
 return __pskb_pull_tail(skb, len-skb_headlen(skb)) != ((void *)0);
}







static inline __attribute__((always_inline)) int skb_headroom(const struct sk_buff *skb)
{
 return skb->data - skb->head;
}







static inline __attribute__((always_inline)) int skb_tailroom(const struct sk_buff *skb)
{
 return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
}
# 953 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_reserve(struct sk_buff *skb, int len)
{
 skb->data += len;
 skb->tail += len;
}
# 1002 "include/linux/skbuff.h"
extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);

static inline __attribute__((always_inline)) void __skb_trim(struct sk_buff *skb, unsigned int len)
{
 if (__builtin_expect(!!(skb->data_len), 0)) {
  ({ typeof(1) __ret_warn_on = (1); if (__builtin_expect(!!(__ret_warn_on), 0)) { printk("BUG: warning at %s:%d/%s()\n", "include/linux/skbuff.h", 1007, (__func__)); dump_stack(); } __builtin_expect(!!(__ret_warn_on), 0); });
  return;
 }
 skb->len = len;
 skb->tail = skb->data + len;
}
# 1023 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_trim(struct sk_buff *skb, unsigned int len)
{
 if (skb->len > len)
  __skb_trim(skb, len);
}


static inline __attribute__((always_inline)) int __pskb_trim(struct sk_buff *skb, unsigned int len)
{
 if (skb->data_len)
  return ___pskb_trim(skb, len);
 __skb_trim(skb, len);
 return 0;
}

static inline __attribute__((always_inline)) int pskb_trim(struct sk_buff *skb, unsigned int len)
{
 return (len < skb->len) ? __pskb_trim(skb, len) : 0;
}
# 1052 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
{
 int err = pskb_trim(skb, len);
 do { if (__builtin_expect(!!((err)!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/skbuff.h", 1055); panic("BUG!"); } while (0); } while(0);
}
# 1066 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_orphan(struct sk_buff *skb)
{
 if (skb->destructor)
  skb->destructor(skb);
 skb->destructor = ((void *)0);
 skb->sk = ((void *)0);
}
# 1082 "include/linux/skbuff.h"
extern void skb_queue_purge(struct sk_buff_head *list);
static inline __attribute__((always_inline)) void __skb_queue_purge(struct sk_buff_head *list)
{
 struct sk_buff *skb;
 while ((skb = __skb_dequeue(list)) != ((void *)0))
  kfree_skb(skb);
}
# 1102 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *__dev_alloc_skb(unsigned int length,
           gfp_t gfp_mask)
{
 struct sk_buff *skb = alloc_skb(length + 16, gfp_mask);
 if (__builtin_expect(!!(skb), 1))
  skb_reserve(skb, 16);
 return skb;
}
# 1123 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *dev_alloc_skb(unsigned int length)
{
 return __dev_alloc_skb(length, ((( gfp_t)0x20u)));
}

extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
  unsigned int length, gfp_t gfp_mask);
# 1144 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) struct sk_buff *netdev_alloc_skb(struct net_device *dev,
  unsigned int length)
{
 return __netdev_alloc_skb(dev, length, ((( gfp_t)0x20u)));
}
# 1162 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_cow(struct sk_buff *skb, unsigned int headroom)
{
 int delta = (headroom > 16 ? headroom : 16) -
   skb_headroom(skb);

 if (delta < 0)
  delta = 0;

 if (delta || skb_cloned(skb))
  return pskb_expand_head(skb, (delta + (16 -1)) &
    ~(16 -1), 0, ((( gfp_t)0x20u)));
 return 0;
}
# 1187 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_padto(struct sk_buff *skb, unsigned int len)
{
 unsigned int size = skb->len;
 if (__builtin_expect(!!(size >= len), 1))
  return 0;
 return skb_pad(skb, len-size);
}

static inline __attribute__((always_inline)) int skb_add_data(struct sk_buff *skb,
          char *from, int copy)
{
 const int off = skb->len;

 if (skb->ip_summed == 0) {
  int err = 0;
  unsigned int csum = csum_and_copy_from_user(from,
           skb_put(skb, copy),
           copy, 0, &err);
  if (!err) {
   skb->csum = csum_block_add(skb->csum, csum, off);
   return 0;
  }
 } else if (!copy_from_user(skb_put(skb, copy), from, copy))
  return 0;

 __skb_trim(skb, off);
 return -14;
}

static inline __attribute__((always_inline)) int skb_can_coalesce(struct sk_buff *skb, int i,
       struct page *page, int off)
{
 if (i) {
  struct skb_frag_struct *frag = &((struct skb_shared_info *)((skb)->end))->frags[i - 1];

  return page == frag->page &&
         off == frag->page_offset + frag->size;
 }
 return 0;
}

static inline __attribute__((always_inline)) int __skb_linearize(struct sk_buff *skb)
{
 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -12;
}
# 1240 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_linearize(struct sk_buff *skb)
{
 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
}
# 1252 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int skb_linearize_cow(struct sk_buff *skb)
{
 return skb_is_nonlinear(skb) || skb_cloned(skb) ?
        __skb_linearize(skb) : 0;
}
# 1269 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_postpull_rcsum(struct sk_buff *skb,
          const void *start, unsigned int len)
{
 if (skb->ip_summed == 3)
  skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
}

unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
# 1287 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
{
 if (__builtin_expect(!!(len >= skb->len), 1))
  return 0;
 if (skb->ip_summed == 3)
  skb->ip_summed = 0;
 return __pskb_trim(skb, len);
}

static inline __attribute__((always_inline)) void *kmap_skb_frag(const skb_frag_t *frag)
{





 return lowmem_page_address(frag->page);
}

static inline __attribute__((always_inline)) void kunmap_skb_frag(void *vaddr)
{
 do { } while (0);



}
# 1325 "include/linux/skbuff.h"
extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
      int noblock, int *err);
extern unsigned int datagram_poll(struct file *file, struct socket *sock,
         struct poll_table_struct *wait);
extern int skb_copy_datagram_iovec(const struct sk_buff *from,
            int offset, struct iovec *to,
            int size);
extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
       int hlen,
       struct iovec *iov);
extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
extern void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
      unsigned int flags);
extern unsigned int skb_checksum(const struct sk_buff *skb, int offset,
        int len, unsigned int csum);
extern int skb_copy_bits(const struct sk_buff *skb, int offset,
         void *to, int len);
extern int skb_store_bits(const struct sk_buff *skb, int offset,
          void *from, int len);
extern unsigned int skb_copy_and_csum_bits(const struct sk_buff *skb,
           int offset, u8 *to, int len,
           unsigned int csum);
extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
extern void skb_split(struct sk_buff *skb,
     struct sk_buff *skb1, const u32 len);

extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);

static inline __attribute__((always_inline)) void *skb_header_pointer(const struct sk_buff *skb, int offset,
           int len, void *buffer)
{
 int hlen = skb_headlen(skb);

 if (hlen - offset >= len)
  return skb->data + offset;

 if (skb_copy_bits(skb, offset, buffer, len) < 0)
  return ((void *)0);

 return buffer;
}

extern void skb_init(void);
extern void skb_add_mtu(int mtu);
# 1379 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_get_timestamp(const struct sk_buff *skb, struct timeval *stamp)
{
 stamp->tv_sec = skb->tstamp.off_sec;
 stamp->tv_usec = skb->tstamp.off_usec;
}
# 1394 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_set_timestamp(struct sk_buff *skb, const struct timeval *stamp)
{
 skb->tstamp.off_sec = stamp->tv_sec;
 skb->tstamp.off_usec = stamp->tv_usec;
}

extern void __net_timestamp(struct sk_buff *skb);

extern unsigned int __skb_checksum_complete(struct sk_buff *skb);
# 1420 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) unsigned int skb_checksum_complete(struct sk_buff *skb)
{
 return skb->ip_summed != 2 &&
  __skb_checksum_complete(skb);
}
# 1476 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void nf_reset(struct sk_buff *skb) {}
# 1490 "include/linux/skbuff.h"
static inline __attribute__((always_inline)) void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
{ }

static inline __attribute__((always_inline)) void skb_init_secmark(struct sk_buff *skb)
{ }


static inline __attribute__((always_inline)) int skb_is_gso(const struct sk_buff *skb)
{
 return ((struct skb_shared_info *)((skb)->end))->gso_size;
}
# 112 "include/linux/if_ether.h" 2

static inline __attribute__((always_inline)) struct ethhdr *eth_hdr(const struct sk_buff *skb)
{
 return (struct ethhdr *)skb->mac.raw;
}


extern struct ctl_table ether_table[];
# 30 "include/linux/netdevice.h" 2
# 1 "include/linux/if_packet.h" 1



struct sockaddr_pkt
{
 unsigned short spkt_family;
 unsigned char spkt_device[14];
 unsigned short spkt_protocol;
};

struct sockaddr_ll
{
 unsigned short sll_family;
 unsigned short sll_protocol;
 int sll_ifindex;
 unsigned short sll_hatype;
 unsigned char sll_pkttype;
 unsigned char sll_halen;
 unsigned char sll_addr[8];
};
# 43 "include/linux/if_packet.h"
struct tpacket_stats
{
 unsigned int tp_packets;
 unsigned int tp_drops;
};

struct tpacket_hdr
{
 unsigned long tp_status;





 unsigned int tp_len;
 unsigned int tp_snaplen;
 unsigned short tp_mac;
 unsigned short tp_net;
 unsigned int tp_sec;
 unsigned int tp_usec;
};
# 82 "include/linux/if_packet.h"
struct tpacket_req
{
 unsigned int tp_block_size;
 unsigned int tp_block_nr;
 unsigned int tp_frame_size;
 unsigned int tp_frame_nr;
};

struct packet_mreq
{
 int mr_ifindex;
 unsigned short mr_type;
 unsigned short mr_alen;
 unsigned char mr_address[8];
};
# 31 "include/linux/netdevice.h" 2






# 1 "include/linux/device.h" 1
# 14 "include/linux/device.h"
# 1 "include/linux/ioport.h" 1
# 17 "include/linux/ioport.h"
struct resource {
 resource_size_t start;
 resource_size_t end;
 const char *name;
 unsigned long flags;
 struct resource *parent, *sibling, *child;
};

struct resource_list {
 struct resource_list *next;
 struct resource *res;
 struct pci_dev *dev;
};
# 94 "include/linux/ioport.h"
extern struct resource ioport_resource;
extern struct resource iomem_resource;

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,
        resource_size_t size, resource_size_t min,
        resource_size_t max, resource_size_t align,
        void (*alignf)(void *, struct resource *,
         resource_size_t, resource_size_t),
        void *alignf_data);
int adjust_resource(struct resource *res, resource_size_t start,
      resource_size_t size);


extern int find_next_system_ram(struct resource *res);






extern struct resource * __request_region(struct resource *,
     resource_size_t start,
     resource_size_t n, const char *name);






extern int __check_region(struct resource *, resource_size_t, resource_size_t);
extern void __release_region(struct resource *, resource_size_t,
    resource_size_t);

static inline __attribute__((always_inline)) int __attribute__((deprecated)) check_region(resource_size_t s,
      resource_size_t n)
{
 return __check_region(&ioport_resource, s, n);
}
# 15 "include/linux/device.h" 2

# 1 "include/linux/klist.h" 1
# 20 "include/linux/klist.h"
struct klist_node;
struct klist {
 spinlock_t k_lock;
 struct list_head k_list;
 void (*get)(struct klist_node *);
 void (*put)(struct klist_node *);
};


extern void klist_init(struct klist * k, void (*get)(struct klist_node *),
         void (*put)(struct klist_node *));

struct klist_node {
 struct klist * n_klist;
 struct list_head n_node;
 struct kref n_ref;
 struct completion n_removed;
};

extern void klist_add_tail(struct klist_node * n, struct klist * k);
extern void klist_add_head(struct klist_node * n, struct klist * k);

extern void klist_del(struct klist_node * n);
extern void klist_remove(struct klist_node * n);

extern int klist_node_attached(struct klist_node * n);


struct klist_iter {
 struct klist * i_klist;
 struct list_head * i_head;
 struct klist_node * i_cur;
};


extern void klist_iter_init(struct klist * k, struct klist_iter * i);
extern void klist_iter_init_node(struct klist * k, struct klist_iter * i,
     struct klist_node * n);
extern void klist_iter_exit(struct klist_iter * i);
extern struct klist_node * klist_next(struct klist_iter * i);
# 17 "include/linux/device.h" 2
# 31 "include/linux/device.h"
struct device;
struct device_driver;
struct class;
struct class_device;

struct bus_type {
 const char * name;

 struct subsystem subsys;
 struct kset drivers;
 struct kset devices;
 struct klist klist_devices;
 struct klist klist_drivers;

 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 (*uevent)(struct device *dev, char **envp,
      int num_envp, char *buffer, int buffer_size);
 int (*probe)(struct device * dev);
 int (*remove)(struct device * dev);
 void (*shutdown)(struct device * dev);

 int (*suspend)(struct device * dev, pm_message_t state);
 int (*suspend_late)(struct device * dev, pm_message_t state);
 int (*resume_early)(struct device * dev);
 int (*resume)(struct device * dev);
};

extern int __attribute__((warn_unused_result)) bus_register(struct bus_type * bus);
extern void bus_unregister(struct bus_type * bus);

extern int __attribute__((warn_unused_result)) bus_rescan_devices(struct bus_type * bus);



int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
       int (*fn)(struct device *, void *));
struct device * bus_find_device(struct bus_type *bus, struct device *start,
    void *data, int (*match)(struct device *, void *));

int __attribute__((warn_unused_result)) 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 __attribute__((warn_unused_result)) bus_create_file(struct bus_type *,
     struct bus_attribute *);
extern void bus_remove_file(struct bus_type *, struct bus_attribute *);

struct device_driver {
 const char * name;
 struct bus_type * bus;

 struct completion unloaded;
 struct kobject kobj;
 struct klist klist_devices;
 struct klist_node knode_bus;

 struct module * owner;

 int (*probe) (struct device * dev);
 int (*remove) (struct device * dev);
 void (*shutdown) (struct device * dev);
 int (*suspend) (struct device * dev, pm_message_t state);
 int (*resume) (struct device * dev);

 unsigned int multithread_probe:1;
};


extern int __attribute__((warn_unused_result)) 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);
extern int driver_probe_done(void);



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 __attribute__((warn_unused_result)) driver_create_file(struct device_driver *,
     struct driver_attribute *);
extern void driver_remove_file(struct device_driver *, struct driver_attribute *);

extern int __attribute__((warn_unused_result)) driver_for_each_device(struct device_driver * drv,
  struct device *start, void *data,
  int (*fn)(struct device *, void *));
struct device * driver_find_device(struct device_driver *drv,
       struct device *start, void *data,
       int (*match)(struct device *, void *));




struct class {
 const char * name;
 struct module * owner;

 struct subsystem subsys;
 struct list_head children;
 struct list_head devices;
 struct list_head interfaces;
 struct semaphore sem;

 struct kobject *virtual_dir;

 struct class_attribute * class_attrs;
 struct class_device_attribute * class_dev_attrs;
 struct device_attribute * dev_attrs;

 int (*uevent)(struct class_device *dev, char **envp,
      int num_envp, char *buffer, int buffer_size);
 int (*dev_uevent)(struct device *dev, char **envp, int num_envp,
    char *buffer, int buffer_size);

 void (*release)(struct class_device *dev);
 void (*class_release)(struct class *class);
 void (*dev_release)(struct device *dev);

 int (*suspend)(struct device *, pm_message_t state);
 int (*resume)(struct device *);
};

extern int __attribute__((warn_unused_result)) class_register(struct class *);
extern void class_unregister(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 __attribute__((warn_unused_result)) class_create_file(struct class *,
     const struct class_attribute *);
extern void class_remove_file(struct class *, const struct class_attribute *);

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 __attribute__((warn_unused_result)) class_device_create_file(struct class_device *,
        const struct class_device_attribute *);
# 231 "include/linux/device.h"
struct class_device {
 struct list_head node;

 struct kobject kobj;
 struct class * class;
 dev_t devt;
 struct class_device_attribute *devt_attr;
 struct class_device_attribute uevent_attr;
 struct device * dev;
 void * class_data;
 struct class_device *parent;
 struct attribute_group ** groups;

 void (*release)(struct class_device *dev);
 int (*uevent)(struct class_device *dev, char **envp,
      int num_envp, char *buffer, int buffer_size);
 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 __attribute__((warn_unused_result)) class_device_register(struct class_device *);
extern void class_device_unregister(struct class_device *);
extern void class_device_initialize(struct class_device *);
extern int __attribute__((warn_unused_result)) 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 *);

extern void class_device_remove_file(struct class_device *,
         const struct class_device_attribute *);
extern int __attribute__((warn_unused_result)) 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 *, struct class_interface *);
 void (*remove) (struct class_device *, struct class_interface *);
 int (*add_dev) (struct device *, struct class_interface *);
 void (*remove_dev) (struct device *, struct class_interface *);
};

extern int __attribute__((warn_unused_result)) class_interface_register(struct class_interface *);
extern void class_interface_unregister(struct class_interface *);

extern struct class *class_create(struct module *owner, const char *name);
extern void class_destroy(struct class *cls);
extern struct class_device *class_device_create(struct class *cls,
      struct class_device *parent,
      dev_t devt,
      struct device *device,
      const char *fmt, ...)
     __attribute__((format(printf,5,6)));
extern void class_device_destroy(struct class *cls, dev_t devt);


struct device_attribute {
 struct attribute attr;
 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
   char *buf);
 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
    const char *buf, size_t count);
};




extern int __attribute__((warn_unused_result)) device_create_file(struct device *device,
     struct device_attribute * entry);
extern void device_remove_file(struct device * dev, struct device_attribute * attr);
extern int __attribute__((warn_unused_result)) device_create_bin_file(struct device *dev,
            struct bin_attribute *attr);
extern void device_remove_bin_file(struct device *dev,
       struct bin_attribute *attr);
struct device {
 struct klist klist_children;
 struct klist_node knode_parent;
 struct klist_node knode_driver;
 struct klist_node knode_bus;
 struct device * parent;

 struct kobject kobj;
 char bus_id[20];
 unsigned is_registered:1;
 struct device_attribute uevent_attr;
 struct device_attribute *devt_attr;

 struct semaphore sem;



 struct bus_type * bus;
 struct device_driver *driver;

 void *driver_data;
 void *platform_data;

 void *firmware_data;

 struct dev_pm_info power;

 u64 *dma_mask;
 u64 coherent_dma_mask;





 struct list_head dma_pools;

 struct dma_coherent_mem *dma_mem;



 struct list_head node;
 struct class *class;
 dev_t devt;
 struct attribute_group **groups;

 void (*release)(struct device * dev);
};

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

static inline __attribute__((always_inline)) int device_is_registered(struct device *dev)
{
 return dev->is_registered;
}




extern int __attribute__((warn_unused_result)) device_register(struct device * dev);
extern void device_unregister(struct device * dev);
extern void device_initialize(struct device * dev);
extern int __attribute__((warn_unused_result)) 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 device_rename(struct device *dev, char *new_name);





extern int __attribute__((warn_unused_result)) device_bind_driver(struct device *dev);
extern void device_release_driver(struct device * dev);
extern int __attribute__((warn_unused_result)) device_attach(struct device * dev);
extern int __attribute__((warn_unused_result)) driver_attach(struct device_driver *drv);
extern int __attribute__((warn_unused_result)) device_reprobe(struct device *dev);




extern struct device *device_create(struct class *cls, struct device *parent,
        dev_t devt, const char *fmt, ...)
        __attribute__((format(printf,4,5)));
extern void device_destroy(struct class *cls, dev_t devt);

extern int virtual_device_parent(struct device *dev);







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 void device_shutdown(void);



extern int __attribute__((warn_unused_result)) firmware_register(struct subsystem *);
extern void firmware_unregister(struct subsystem *);


extern const char *dev_driver_string(struct device *dev);
# 38 "include/linux/netdevice.h" 2



struct divert_blk;
struct vlan_group;
struct ethtool_ops;
struct netpoll_info;
# 110 "include/linux/netdevice.h"
struct net_device_stats
{
 unsigned long rx_packets;
 unsigned long tx_packets;
 unsigned long rx_bytes;
 unsigned long tx_bytes;
 unsigned long rx_errors;
 unsigned long tx_errors;
 unsigned long rx_dropped;
 unsigned long tx_dropped;
 unsigned long multicast;
 unsigned long collisions;


 unsigned long rx_length_errors;
 unsigned long rx_over_errors;
 unsigned long rx_crc_errors;
 unsigned long rx_frame_errors;
 unsigned long rx_fifo_errors;
 unsigned long rx_missed_errors;


 unsigned long tx_aborted_errors;
 unsigned long tx_carrier_errors;
 unsigned long tx_fifo_errors;
 unsigned long tx_heartbeat_errors;
 unsigned long tx_window_errors;


 unsigned long rx_compressed;
 unsigned long tx_compressed;
};



enum {
        IF_PORT_UNKNOWN = 0,
        IF_PORT_10BASE2,
        IF_PORT_10BASET,
        IF_PORT_AUI,
        IF_PORT_100BASET,
        IF_PORT_100BASETX,
        IF_PORT_100BASEFX
};






struct neighbour;
struct neigh_parms;
struct sk_buff;

struct netif_rx_stats
{
 unsigned total;
 unsigned dropped;
 unsigned time_squeeze;
 unsigned cpu_collision;
};

extern __typeof__(struct netif_rx_stats) per_cpu__netdev_rx_stat;






struct dev_mc_list
{
 struct dev_mc_list *next;
 __u8 dmi_addr[32];
 unsigned char dmi_addrlen;
 int dmi_users;
 int dmi_gusers;
};

struct hh_cache
{
 struct hh_cache *hh_next;
 atomic_t hh_refcnt;
 __be16 hh_type;



 int hh_len;
 int (*hh_output)(struct sk_buff *skb);
 rwlock_t hh_lock;







 unsigned long hh_data[(((32)+(16 -1))&~(16 - 1)) / sizeof(long)];
};
# 227 "include/linux/netdevice.h"
enum netdev_state_t
{
 __LINK_STATE_XOFF=0,
 __LINK_STATE_START,
 __LINK_STATE_PRESENT,
 __LINK_STATE_SCHED,
 __LINK_STATE_NOCARRIER,
 __LINK_STATE_RX_SCHED,
 __LINK_STATE_LINKWATCH_PENDING,
 __LINK_STATE_DORMANT,
 __LINK_STATE_QDISC_RUNNING,
};






struct netdev_boot_setup {
 char name[16];
 struct ifmap map;
};


extern int __attribute__ ((__section__ (".init.text"))) netdev_boot_setup(char *str);
# 263 "include/linux/netdevice.h"
struct net_device
{






 char name[16];

 struct hlist_node name_hlist;





 unsigned long mem_end;
 unsigned long mem_start;
 unsigned long base_addr;
 unsigned int irq;






 unsigned char if_port;
 unsigned char dma;

 unsigned long state;

 struct net_device *next;


 int (*init)(struct net_device *dev);




 unsigned long features;
# 331 "include/linux/netdevice.h"
 struct net_device *next_sched;


 int ifindex;
 int iflink;


 struct net_device_stats* (*get_stats)(struct net_device *dev);



 const struct iw_handler_def * wireless_handlers;

 struct iw_public_data * wireless_data;

 const struct ethtool_ops *ethtool_ops;
# 355 "include/linux/netdevice.h"
 unsigned int flags;
 unsigned short gflags;
        unsigned short priv_flags;
 unsigned short padded;

 unsigned char operstate;
 unsigned char link_mode;

 unsigned mtu;
 unsigned short type;
 unsigned short hard_header_len;

 struct net_device *master;




 unsigned char perm_addr[32];
 unsigned char addr_len;
 unsigned short dev_id;

 struct dev_mc_list *mc_list;
 int mc_count;
 int promiscuity;
 int allmulti;




 void *atalk_ptr;
 void *ip_ptr;
 void *dn_ptr;
 void *ip6_ptr;
 void *ec_ptr;
 void *ax25_ptr;




 struct list_head poll_list ;


 int (*poll) (struct net_device *dev, int *quota);
 int quota;
 int weight;
 unsigned long last_rx;

 unsigned char dev_addr[32];


 unsigned char broadcast[32];





 spinlock_t queue_lock ;
 struct Qdisc *qdisc;
 struct Qdisc *qdisc_sleeping;
 struct list_head qdisc_list;
 unsigned long tx_queue_len;


 struct sk_buff *gso_skb;


 spinlock_t ingress_lock;
 struct Qdisc *qdisc_ingress;





 spinlock_t _xmit_lock ;



 int xmit_lock_owner;
 void *priv;
 int (*hard_start_xmit) (struct sk_buff *skb,
          struct net_device *dev);

 unsigned long trans_start;

 int watchdog_timeo;
 struct timer_list watchdog_timer;





 atomic_t refcnt ;


 struct list_head todo_list;

 struct hlist_node index_hlist;


 enum { NETREG_UNINITIALIZED=0,
        NETREG_REGISTERED,
        NETREG_UNREGISTERING,
        NETREG_UNREGISTERED,
        NETREG_RELEASED,
 } reg_state;


 void (*uninit)(struct net_device *dev);

 void (*destructor)(struct net_device *dev);


 int (*open)(struct net_device *dev);
 int (*stop)(struct net_device *dev);

 int (*hard_header) (struct sk_buff *skb,
      struct net_device *dev,
      unsigned short type,
      void *daddr,
      void *saddr,
      unsigned len);
 int (*rebuild_header)(struct sk_buff *skb);

 void (*set_multicast_list)(struct net_device *dev);

 int (*set_mac_address)(struct net_device *dev,
         void *addr);

 int (*do_ioctl)(struct net_device *dev,
         struct ifreq *ifr, int cmd);

 int (*set_config)(struct net_device *dev,
           struct ifmap *map);

 int (*hard_header_cache)(struct neighbour *neigh,
           struct hh_cache *hh);
 void (*header_cache_update)(struct hh_cache *hh,
             struct net_device *dev,
             unsigned char * haddr);

 int (*change_mtu)(struct net_device *dev, int new_mtu);


 void (*tx_timeout) (struct net_device *dev);

 void (*vlan_rx_register)(struct net_device *dev,
          struct vlan_group *grp);
 void (*vlan_rx_add_vid)(struct net_device *dev,
         unsigned short vid);
 void (*vlan_rx_kill_vid)(struct net_device *dev,
          unsigned short vid);

 int (*hard_header_parse)(struct sk_buff *skb,
           unsigned char *haddr);
 int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);

 struct netpoll_info *npinfo;


 void (*poll_controller)(struct net_device *dev);



 struct net_bridge_port *br_port;







 struct class_device class_dev;

 struct attribute_group *sysfs_groups[3];
};




static inline __attribute__((always_inline)) void *netdev_priv(struct net_device *dev)
{
 return (char *)dev + ((sizeof(struct net_device)
     + (32 - 1))
    & ~(32 - 1));
}







struct packet_type {
 __be16 type;
 struct net_device *dev;
 int (*func) (struct sk_buff *,
      struct net_device *,
      struct packet_type *,
      struct net_device *);
 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
      int features);
 int (*gso_send_check)(struct sk_buff *skb);
 void *af_packet_priv;
 struct list_head list;
};

# 1 "include/linux/interrupt.h" 1
# 10 "include/linux/interrupt.h"
# 1 "include/linux/irqreturn.h" 1
# 19 "include/linux/irqreturn.h"
typedef int irqreturn_t;
# 11 "include/linux/interrupt.h" 2


# 1 "include/linux/irqflags.h" 1
# 14 "include/linux/interrupt.h" 2
# 1 "include/linux/bottom_half.h" 1
extern void local_bh_disable(void);
extern void __local_bh_enable(void);
extern void _local_bh_enable(void);
extern void local_bh_enable(void);
extern void local_bh_enable_ip(unsigned long ip);
# 15 "include/linux/interrupt.h" 2
# 68 "include/linux/interrupt.h"
typedef irqreturn_t (*irq_handler_t)(int, void *);

struct irqaction {
 irq_handler_t handler;
 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);
extern int request_irq(unsigned int, irq_handler_t handler,
         unsigned long, const char *, void *);
extern void free_irq(unsigned int, void *);
# 105 "include/linux/interrupt.h"
extern void disable_irq_nosync(unsigned int irq);
extern void disable_irq(unsigned int irq);
extern void enable_irq(unsigned int irq);
# 120 "include/linux/interrupt.h"
static inline __attribute__((always_inline)) void disable_irq_nosync_lockdep(unsigned int irq)
{
 disable_irq_nosync(irq);



}

static inline __attribute__((always_inline)) void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
{
 disable_irq_nosync(irq);



}

static inline __attribute__((always_inline)) void disable_irq_lockdep(unsigned int irq)
{
 disable_irq(irq);



}

static inline __attribute__((always_inline)) void enable_irq_lockdep(unsigned int irq)
{



 enable_irq(irq);
}

static inline __attribute__((always_inline)) void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
{



 enable_irq(irq);
}


extern int set_irq_wake(unsigned int irq, unsigned int on);

static inline __attribute__((always_inline)) int enable_irq_wake(unsigned int irq)
{
 return set_irq_wake(irq, 1);
}

static inline __attribute__((always_inline)) int disable_irq_wake(unsigned int irq)
{
 return set_irq_wake(irq, 0);
}
# 196 "include/linux/interrupt.h"
static inline __attribute__((always_inline)) void __attribute__((deprecated)) cli(void)
{
 do { int _tmp_dummy; __asm__ __volatile__ ( "cli %0;" :"=d" (_tmp_dummy):); } while (0);
}
static inline __attribute__((always_inline)) void __attribute__((deprecated)) sti(void)
{
 do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0);
}
static inline __attribute__((always_inline)) void __attribute__((deprecated)) save_flags(unsigned long *x)
{
 asm volatile ("cli %0;" "sti %0;" :"=d"(*x):);;
}

static inline __attribute__((always_inline)) void __attribute__((deprecated)) restore_flags(unsigned long x)
{
 do { if (((x) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static inline __attribute__((always_inline)) void __attribute__((deprecated)) save_and_cli(unsigned long *x)
{
 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(*x):); } while (0);
}
# 227 "include/linux/interrupt.h"
enum
{
 HI_SOFTIRQ=0,
 TIMER_SOFTIRQ,
 NET_TX_SOFTIRQ,
 NET_RX_SOFTIRQ,
 BLOCK_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);
# 275 "include/linux/interrupt.h"
struct tasklet_struct
{
 struct tasklet_struct *next;
 unsigned long state;
 atomic_t count;
 void (*func)(unsigned long);
 unsigned long data;
};
# 291 "include/linux/interrupt.h"
enum
{
 TASKLET_STATE_SCHED,
 TASKLET_STATE_RUN
};
# 319 "include/linux/interrupt.h"
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);
# 408 "include/linux/interrupt.h"
extern unsigned long probe_irq_on(void);
extern int probe_irq_off(unsigned long);
extern unsigned int probe_irq_mask(unsigned long);
# 562 "include/linux/netdevice.h" 2


extern struct net_device loopback_dev;
extern struct net_device *dev_base;
extern rwlock_t dev_base_lock;

extern int netdev_boot_setup_check(struct net_device *dev);
extern unsigned long netdev_boot_base(const char *prefix, int unit);
extern struct net_device *dev_getbyhwaddr(unsigned short type, char *hwaddr);
extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
extern void dev_add_pack(struct packet_type *pt);
extern void dev_remove_pack(struct packet_type *pt);
extern void __dev_remove_pack(struct packet_type *pt);

extern struct net_device *dev_get_by_flags(unsigned short flags,
        unsigned short mask);
extern struct net_device *dev_get_by_name(const char *name);
extern struct net_device *__dev_get_by_name(const char *name);
extern int dev_alloc_name(struct net_device *dev, const char *name);
extern int dev_open(struct net_device *dev);
extern int dev_close(struct net_device *dev);
extern int dev_queue_xmit(struct sk_buff *skb);
extern int register_netdevice(struct net_device *dev);
extern int unregister_netdevice(struct net_device *dev);
extern void free_netdev(struct net_device *dev);
extern void synchronize_net(void);
extern int register_netdevice_notifier(struct notifier_block *nb);
extern int unregister_netdevice_notifier(struct notifier_block *nb);
extern int call_netdevice_notifiers(unsigned long val, void *v);
extern struct net_device *dev_get_by_index(int ifindex);
extern struct net_device *__dev_get_by_index(int ifindex);
extern int dev_restart(struct net_device *dev);

extern int netpoll_trap(void);


typedef int gifconf_func_t(struct net_device * dev, char * bufptr, int len);
extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
static inline __attribute__((always_inline)) int unregister_gifconf(unsigned int family)
{
 return register_gifconf(family, ((void *)0));
}






struct softnet_data
{
 struct net_device *output_queue;
 struct sk_buff_head input_pkt_queue;
 struct list_head poll_list;
 struct sk_buff *completion_queue;

 struct net_device backlog_dev;



};

extern __typeof__(struct softnet_data) per_cpu__softnet_data;



extern void __netif_schedule(struct net_device *dev);

static inline __attribute__((always_inline)) void netif_schedule(struct net_device *dev)
{
 if (!(__builtin_constant_p(__LINK_STATE_XOFF) ? __constant_test_bit((__LINK_STATE_XOFF),(&dev->state)) : __test_bit((__LINK_STATE_XOFF),(&dev->state))))
  __netif_schedule(dev);
}

static inline __attribute__((always_inline)) void netif_start_queue(struct net_device *dev)
{
 clear_bit(__LINK_STATE_XOFF, &dev->state);
}

static inline __attribute__((always_inline)) void netif_wake_queue(struct net_device *dev)
{

 if (netpoll_trap())
  return;

 if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
  __netif_schedule(dev);
}

static inline __attribute__((always_inline)) void netif_stop_queue(struct net_device *dev)
{

 if (netpoll_trap())
  return;

 set_bit(__LINK_STATE_XOFF, &dev->state);
}

static inline __attribute__((always_inline)) int netif_queue_stopped(const struct net_device *dev)
{
 return (__builtin_constant_p(__LINK_STATE_XOFF) ? __constant_test_bit((__LINK_STATE_XOFF),(&dev->state)) : __test_bit((__LINK_STATE_XOFF),(&dev->state)));
}

static inline __attribute__((always_inline)) int netif_running(const struct net_device *dev)
{
 return (__builtin_constant_p(__LINK_STATE_START) ? __constant_test_bit((__LINK_STATE_START),(&dev->state)) : __test_bit((__LINK_STATE_START),(&dev->state)));
}





static inline __attribute__((always_inline)) void dev_kfree_skb_irq(struct sk_buff *skb)
{
 if ((atomic_sub_return(1, (&skb->users)) == 0)) {
  struct softnet_data *sd;
  unsigned long flags;

  do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
  sd = &per_cpu__softnet_data;
  skb->next = sd->completion_queue;
  sd->completion_queue = skb;
  raise_softirq_irqoff(NET_TX_SOFTIRQ);
  do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
 }
}




extern void dev_kfree_skb_any(struct sk_buff *skb);


extern int netif_rx(struct sk_buff *skb);
extern int netif_rx_ni(struct sk_buff *skb);

extern int netif_receive_skb(struct sk_buff *skb);
extern int dev_valid_name(const char *name);
extern int dev_ioctl(unsigned int cmd, void *);
extern int dev_ethtool(struct ifreq *);
extern unsigned dev_get_flags(const struct net_device *);
extern int dev_change_flags(struct net_device *, unsigned);
extern int dev_change_name(struct net_device *, char *);
extern int dev_set_mtu(struct net_device *, int);
extern int dev_set_mac_address(struct net_device *,
         struct sockaddr *);
extern int dev_hard_start_xmit(struct sk_buff *skb,
         struct net_device *dev);

extern void dev_init(void);

extern int netdev_budget;


extern void netdev_run_todo(void);

static inline __attribute__((always_inline)) void dev_put(struct net_device *dev)
{
 atomic_dec(&dev->refcnt);
}

static inline __attribute__((always_inline)) void dev_hold(struct net_device *dev)
{
 atomic_inc(&dev->refcnt);
}
# 736 "include/linux/netdevice.h"
extern void linkwatch_fire_event(struct net_device *dev);

static inline __attribute__((always_inline)) int netif_carrier_ok(const struct net_device *dev)
{
 return !(__builtin_constant_p(__LINK_STATE_NOCARRIER) ? __constant_test_bit((__LINK_STATE_NOCARRIER),(&dev->state)) : __test_bit((__LINK_STATE_NOCARRIER),(&dev->state)));
}

extern void __netdev_watchdog_up(struct net_device *dev);

extern void netif_carrier_on(struct net_device *dev);

extern void netif_carrier_off(struct net_device *dev);

static inline __attribute__((always_inline)) void netif_dormant_on(struct net_device *dev)
{
 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
  linkwatch_fire_event(dev);
}

static inline __attribute__((always_inline)) void netif_dormant_off(struct net_device *dev)
{
 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
  linkwatch_fire_event(dev);
}

static inline __attribute__((always_inline)) int netif_dormant(const struct net_device *dev)
{
 return (__builtin_constant_p(__LINK_STATE_DORMANT) ? __constant_test_bit((__LINK_STATE_DORMANT),(&dev->state)) : __test_bit((__LINK_STATE_DORMANT),(&dev->state)));
}


static inline __attribute__((always_inline)) int netif_oper_up(const struct net_device *dev) {
 return (dev->operstate == IF_OPER_UP ||
  dev->operstate == IF_OPER_UNKNOWN );
}


static inline __attribute__((always_inline)) int netif_device_present(struct net_device *dev)
{
 return (__builtin_constant_p(__LINK_STATE_PRESENT) ? __constant_test_bit((__LINK_STATE_PRESENT),(&dev->state)) : __test_bit((__LINK_STATE_PRESENT),(&dev->state)));
}

extern void netif_device_detach(struct net_device *dev);

extern void netif_device_attach(struct net_device *dev);






enum {
 NETIF_MSG_DRV = 0x0001,
 NETIF_MSG_PROBE = 0x0002,
 NETIF_MSG_LINK = 0x0004,
 NETIF_MSG_TIMER = 0x0008,
 NETIF_MSG_IFDOWN = 0x0010,
 NETIF_MSG_IFUP = 0x0020,
 NETIF_MSG_RX_ERR = 0x0040,
 NETIF_MSG_TX_ERR = 0x0080,
 NETIF_MSG_TX_QUEUED = 0x0100,
 NETIF_MSG_INTR = 0x0200,
 NETIF_MSG_TX_DONE = 0x0400,
 NETIF_MSG_RX_STATUS = 0x0800,
 NETIF_MSG_PKTDATA = 0x1000,
 NETIF_MSG_HW = 0x2000,
 NETIF_MSG_WOL = 0x4000,
};
# 821 "include/linux/netdevice.h"
static inline __attribute__((always_inline)) u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
{

 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  return default_msg_enable_bits;
 if (debug_value == 0)
  return 0;

 return (1 << debug_value) - 1;
}


static inline __attribute__((always_inline)) int __netif_rx_schedule_prep(struct net_device *dev)
{
 return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
}


static inline __attribute__((always_inline)) int netif_rx_schedule_prep(struct net_device *dev)
{
 return netif_running(dev) && __netif_rx_schedule_prep(dev);
}





extern void __netif_rx_schedule(struct net_device *dev);



static inline __attribute__((always_inline)) void netif_rx_schedule(struct net_device *dev)
{
 if (netif_rx_schedule_prep(dev))
  __netif_rx_schedule(dev);
}




static inline __attribute__((always_inline)) int netif_rx_reschedule(struct net_device *dev, int undo)
{
 if (netif_rx_schedule_prep(dev)) {
  unsigned long flags;

  dev->quota += undo;

  do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
  list_add_tail(&dev->poll_list, &per_cpu__softnet_data.poll_list);
  do { ((irq_stat[0].__softirq_pending) |= (1UL << (NET_RX_SOFTIRQ))); } while (0);
  do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
  return 1;
 }
 return 0;
}






static inline __attribute__((always_inline)) void netif_rx_complete(struct net_device *dev)
{
 unsigned long flags;

 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
 do { if (__builtin_expect(!!((!(__builtin_constant_p(__LINK_STATE_RX_SCHED) ? __constant_test_bit((__LINK_STATE_RX_SCHED),(&dev->state)) : __test_bit((__LINK_STATE_RX_SCHED),(&dev->state))))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/netdevice.h", 887); panic("BUG!"); } while (0); } while(0);
 list_del(&dev->poll_list);
 __asm__ __volatile__("": : :"memory");
 clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
}

static inline __attribute__((always_inline)) void netif_poll_disable(struct net_device *dev)
{
 while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state))

  schedule_timeout_interruptible(1);
}

static inline __attribute__((always_inline)) void netif_poll_enable(struct net_device *dev)
{
 clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
}




static inline __attribute__((always_inline)) void __netif_rx_complete(struct net_device *dev)
{
 do { if (__builtin_expect(!!((!(__builtin_constant_p(__LINK_STATE_RX_SCHED) ? __constant_test_bit((__LINK_STATE_RX_SCHED),(&dev->state)) : __test_bit((__LINK_STATE_RX_SCHED),(&dev->state))))!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "include/linux/netdevice.h", 911); panic("BUG!"); } while (0); } while(0);
 list_del(&dev->poll_list);
 __asm__ __volatile__("": : :"memory");
 clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
}

static inline __attribute__((always_inline)) void netif_tx_lock(struct net_device *dev)
{
 do { do { } while (0); (void)0; (void)(&dev->_xmit_lock); } while (0);
 dev->xmit_lock_owner = 0;
}

static inline __attribute__((always_inline)) void netif_tx_lock_bh(struct net_device *dev)
{
 do { local_bh_disable(); do { do { } while (0); (void)0; (void)(&dev->_xmit_lock); } while (0); } while (0);
 dev->xmit_lock_owner = 0;
}

static inline __attribute__((always_inline)) int netif_tx_trylock(struct net_device *dev)
{
 int ok = (({ do { do { } while (0); (void)0; (void)(&dev->_xmit_lock); } while (0); 1; }));
 if (__builtin_expect(!!(ok), 1))
  dev->xmit_lock_owner = 0;
 return ok;
}

static inline __attribute__((always_inline)) void netif_tx_unlock(struct net_device *dev)
{
 dev->xmit_lock_owner = -1;
 do { do { } while (0); (void)0; (void)(&dev->_xmit_lock); } while (0);
}

static inline __attribute__((always_inline)) void netif_tx_unlock_bh(struct net_device *dev)
{
 dev->xmit_lock_owner = -1;
 do { do { } while (0); local_bh_enable(); (void)0; (void)(&dev->_xmit_lock); } while (0);
}

static inline __attribute__((always_inline)) void netif_tx_disable(struct net_device *dev)
{
 netif_tx_lock_bh(dev);
 netif_stop_queue(dev);
 netif_tx_unlock_bh(dev);
}



extern void ether_setup(struct net_device *dev);


extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
           void (*setup)(struct net_device *));
extern int register_netdev(struct net_device *dev);
extern void unregister_netdev(struct net_device *dev);

extern void dev_mc_upload(struct net_device *dev);
extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
extern void dev_mc_discard(struct net_device *dev);
extern void dev_set_promiscuity(struct net_device *dev, int inc);
extern void dev_set_allmulti(struct net_device *dev, int inc);
extern void netdev_state_change(struct net_device *dev);
extern void netdev_features_change(struct net_device *dev);

extern void dev_load(const char *name);
extern void dev_mcast_init(void);
extern int netdev_max_backlog;
extern int weight_p;
extern int netdev_set_master(struct net_device *dev, struct net_device *master);
extern int skb_checksum_help(struct sk_buff *skb);
extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);

extern void netdev_rx_csum_fault(struct net_device *dev);






extern void net_enable_timestamp(void);
extern void net_disable_timestamp(void);


extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
extern void dev_seq_stop(struct seq_file *seq, void *v);


extern void linkwatch_run_queue(void);

static inline __attribute__((always_inline)) int net_gso_ok(int features, int gso_type)
{
 int feature = gso_type << 16;
 return (features & feature) == feature;
}

static inline __attribute__((always_inline)) int skb_gso_ok(struct sk_buff *skb, int features)
{
 return net_gso_ok(features, ((struct skb_shared_info *)((skb)->end))->gso_type);
}

static inline __attribute__((always_inline)) int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
{
 return skb_is_gso(skb) &&
        (!skb_gso_ok(skb, dev->features) ||
  __builtin_expect(!!(skb->ip_summed != 1), 0));
}





static inline __attribute__((always_inline)) int skb_bond_should_drop(struct sk_buff *skb)
{
 struct net_device *dev = skb->dev;
 struct net_device *master = dev->master;

 if (master &&
     (dev->priv_flags & 0x4)) {
  if ((dev->priv_flags & 0x40) &&
      skb->protocol == (( __be16)((__u16)( (((__u16)((0x0806)) & (__u16)0x00ffU) << 8) | (((__u16)((0x0806)) & (__u16)0xff00U) >> 8) ))))
   return 0;

  if (master->priv_flags & 0x10) {
   if (skb->pkt_type != 1 &&
       skb->pkt_type != 2)
    return 0;
  }
  if (master->priv_flags & 0x8 &&
      skb->protocol == (( __be16)((__u16)( (((__u16)((0x8809)) & (__u16)0x00ffU) << 8) | (((__u16)((0x8809)) & (__u16)0xff00U) >> 8) ))))
   return 0;

  return 1;
 }
 return 0;
}
# 62 "net/ipv4/ip_output.c" 2
# 1 "include/linux/etherdevice.h" 1
# 32 "include/linux/etherdevice.h"
extern int eth_header(struct sk_buff *skb, struct net_device *dev,
       unsigned short type, void *daddr,
       void *saddr, unsigned len);
extern int eth_rebuild_header(struct sk_buff *skb);
extern __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev);
extern void eth_header_cache_update(struct hh_cache *hh, struct net_device *dev,
      unsigned char * haddr);
extern int eth_header_cache(struct neighbour *neigh,
      struct hh_cache *hh);

extern struct net_device *alloc_etherdev(int sizeof_priv);
static inline __attribute__((always_inline)) void eth_copy_and_sum (struct sk_buff *dest,
         const unsigned char *src,
         int len, int base)
{
 memcpy (dest->data, src, len);
}







static inline __attribute__((always_inline)) int is_zero_ether_addr(const u8 *addr)
{
 return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
}
# 68 "include/linux/etherdevice.h"
static inline __attribute__((always_inline)) int is_multicast_ether_addr(const u8 *addr)
{
 return (0x01 & addr[0]);
}







static inline __attribute__((always_inline)) int is_broadcast_ether_addr(const u8 *addr)
{
 return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
}
# 93 "include/linux/etherdevice.h"
static inline __attribute__((always_inline)) int is_valid_ether_addr(const u8 *addr)
{


 return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
}
# 107 "include/linux/etherdevice.h"
static inline __attribute__((always_inline)) void random_ether_addr(u8 *addr)
{
 get_random_bytes (addr, 6);
 addr [0] &= 0xfe;
 addr [0] |= 0x02;
}
# 121 "include/linux/etherdevice.h"
static inline __attribute__((always_inline)) unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2)
{
 const u16 *a = (const u16 *) addr1;
 const u16 *b = (const u16 *) addr2;

 ((void)sizeof(char[1 - 2*!!(6 != 6)]));
 return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
}
# 63 "net/ipv4/ip_output.c" 2
# 1 "include/linux/proc_fs.h" 1






# 1 "include/linux/magic.h" 1
# 8 "include/linux/proc_fs.h" 2
# 24 "include/linux/proc_fs.h"
enum {
 PROC_ROOT_INO = 1,
};
# 43 "include/linux/proc_fs.h"
typedef int (read_proc_t)(char *page, char **start, off_t off,
     int count, int *eof, void *data);
typedef int (write_proc_t)(struct file *file, const char *buffer,
      unsigned long count, void *data);
typedef int (get_info_t)(char *, char **, off_t, int);

struct proc_dir_entry {
 unsigned int low_ino;
 unsigned short namelen;
 const char *name;
 mode_t mode;
 nlink_t nlink;
 uid_t uid;
 gid_t gid;
 loff_t size;
 struct inode_operations * proc_iops;
 const struct file_operations * proc_fops;
 get_info_t *get_info;
 struct module *owner;
 struct proc_dir_entry *next, *parent, *subdir;
 void *data;
 read_proc_t *read_proc;
 write_proc_t *write_proc;
 atomic_t count;
 int deleted;
 void *set;
};

struct kcore_list {
 struct kcore_list *next;
 unsigned long addr;
 size_t size;
};

struct vmcore {
 struct list_head list;
 unsigned long long paddr;
 unsigned long long size;
 loff_t offset;
};



extern struct proc_dir_entry proc_root;
extern struct proc_dir_entry *proc_root_fs;
extern struct proc_dir_entry *proc_net;
extern struct proc_dir_entry *proc_net_stat;
extern struct proc_dir_entry *proc_bus;
extern struct proc_dir_entry *proc_root_driver;
extern struct proc_dir_entry *proc_root_kcore;

extern spinlock_t proc_subdir_lock;

extern void proc_root_init(void);
extern void proc_misc_init(void);

struct mm_struct;

void proc_flush_task(struct task_struct *task);
struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *);
int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir);
unsigned long task_vsize(struct mm_struct *);
int task_statm(struct mm_struct *, int *, int *, int *, int *);
char *task_mem(struct mm_struct *, char *);

extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
      struct proc_dir_entry *parent);
extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);

extern struct vfsmount *proc_mnt;
extern int proc_fill_super(struct super_block *,void *,int);
extern struct inode *proc_get_inode(struct super_block *, unsigned int, struct proc_dir_entry *);

extern int proc_match(int, const char *,struct proc_dir_entry *);
# 125 "include/linux/proc_fs.h"
extern int proc_readdir(struct file *, void *, filldir_t);
extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *);

extern const struct file_operations proc_kcore_operations;
extern const struct file_operations proc_kmsg_operations;
extern const struct file_operations ppc_htab_operations;




struct tty_driver;
extern void proc_tty_init(void);
extern void proc_tty_register_driver(struct tty_driver *driver);
extern void proc_tty_unregister_driver(struct tty_driver *driver);
# 156 "include/linux/proc_fs.h"
extern struct proc_dir_entry *proc_symlink(const char *,
  struct proc_dir_entry *, const char *);
extern struct proc_dir_entry *proc_mkdir(const char *,struct proc_dir_entry *);
extern struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
   struct proc_dir_entry *parent);

static inline __attribute__((always_inline)) struct proc_dir_entry *create_proc_read_entry(const char *name,
 mode_t mode, struct proc_dir_entry *base,
 read_proc_t *read_proc, void * data)
{
 struct proc_dir_entry *res=create_proc_entry(name,mode,base);
 if (res) {
  res->read_proc=read_proc;
  res->data=data;
 }
 return res;
}

static inline __attribute__((always_inline)) struct proc_dir_entry *create_proc_info_entry(const char *name,
 mode_t mode, struct proc_dir_entry *base, get_info_t *get_info)
{
 struct proc_dir_entry *res=create_proc_entry(name,mode,base);
 if (res) res->get_info=get_info;
 return res;
}

static inline __attribute__((always_inline)) struct proc_dir_entry *proc_net_create(const char *name,
 mode_t mode, get_info_t *get_info)
{
 return create_proc_info_entry(name,mode,proc_net,get_info);
}

static inline __attribute__((always_inline)) struct proc_dir_entry *proc_net_fops_create(const char *name,
 mode_t mode, const struct file_operations *fops)
{
 struct proc_dir_entry *res = create_proc_entry(name, mode, proc_net);
 if (res)
  res->proc_fops = fops;
 return res;
}

static inline __attribute__((always_inline)) void proc_net_remove(const char *name)
{
 remove_proc_entry(name,proc_net);
}
# 240 "include/linux/proc_fs.h"
static inline __attribute__((always_inline)) void kclist_add(struct kcore_list *new, void *addr, size_t size)
{
}




union proc_op {
 int (*proc_get_link)(struct inode *, struct dentry **, struct vfsmount **);
 int (*proc_read)(struct task_struct *task, char *page);
};

struct proc_inode {
 struct pid *pid;
 int fd;
 union proc_op op;
 struct proc_dir_entry *pde;
 struct inode vfs_inode;
};

static inline __attribute__((always_inline)) struct proc_inode *PROC_I(const struct inode *inode)
{
 return ({ const typeof( ((struct proc_inode *)0)->vfs_inode ) *__mptr = (inode); (struct proc_inode *)( (char *)__mptr - __builtin_offsetof(struct proc_inode,vfs_inode) );});
}

static inline __attribute__((always_inline)) struct proc_dir_entry *PDE(const struct inode *inode)
{
 return PROC_I(inode)->pde;
}

struct proc_maps_private {
 struct pid *pid;
 struct task_struct *task;



};
# 64 "net/ipv4/ip_output.c" 2



# 1 "include/net/snmp.h" 1
# 25 "include/net/snmp.h"
# 1 "include/linux/snmp.h" 1
# 18 "include/linux/snmp.h"
enum
{
 IPSTATS_MIB_NUM = 0,
 IPSTATS_MIB_INRECEIVES,
 IPSTATS_MIB_INHDRERRORS,
 IPSTATS_MIB_INTOOBIGERRORS,
 IPSTATS_MIB_INNOROUTES,
 IPSTATS_MIB_INADDRERRORS,
 IPSTATS_MIB_INUNKNOWNPROTOS,
 IPSTATS_MIB_INTRUNCATEDPKTS,
 IPSTATS_MIB_INDISCARDS,
 IPSTATS_MIB_INDELIVERS,
 IPSTATS_MIB_OUTFORWDATAGRAMS,
 IPSTATS_MIB_OUTREQUESTS,
 IPSTATS_MIB_OUTDISCARDS,
 IPSTATS_MIB_OUTNOROUTES,
 IPSTATS_MIB_REASMTIMEOUT,
 IPSTATS_MIB_REASMREQDS,
 IPSTATS_MIB_REASMOKS,
 IPSTATS_MIB_REASMFAILS,
 IPSTATS_MIB_FRAGOKS,
 IPSTATS_MIB_FRAGFAILS,
 IPSTATS_MIB_FRAGCREATES,
 IPSTATS_MIB_INMCASTPKTS,
 IPSTATS_MIB_OUTMCASTPKTS,
 __IPSTATS_MIB_MAX
};






enum
{
 ICMP_MIB_NUM = 0,
 ICMP_MIB_INMSGS,
 ICMP_MIB_INERRORS,
 ICMP_MIB_INDESTUNREACHS,
 ICMP_MIB_INTIMEEXCDS,
 ICMP_MIB_INPARMPROBS,
 ICMP_MIB_INSRCQUENCHS,
 ICMP_MIB_INREDIRECTS,
 ICMP_MIB_INECHOS,
 ICMP_MIB_INECHOREPS,
 ICMP_MIB_INTIMESTAMPS,
 ICMP_MIB_INTIMESTAMPREPS,
 ICMP_MIB_INADDRMASKS,
 ICMP_MIB_INADDRMASKREPS,
 ICMP_MIB_OUTMSGS,
 ICMP_MIB_OUTERRORS,
 ICMP_MIB_OUTDESTUNREACHS,
 ICMP_MIB_OUTTIMEEXCDS,
 ICMP_MIB_OUTPARMPROBS,
 ICMP_MIB_OUTSRCQUENCHS,
 ICMP_MIB_OUTREDIRECTS,
 ICMP_MIB_OUTECHOS,
 ICMP_MIB_OUTECHOREPS,
 ICMP_MIB_OUTTIMESTAMPS,
 ICMP_MIB_OUTTIMESTAMPREPS,
 ICMP_MIB_OUTADDRMASKS,
 ICMP_MIB_OUTADDRMASKREPS,
 __ICMP_MIB_MAX
};





enum
{
 ICMP6_MIB_NUM = 0,
 ICMP6_MIB_INMSGS,
 ICMP6_MIB_INERRORS,
 ICMP6_MIB_INDESTUNREACHS,
 ICMP6_MIB_INPKTTOOBIGS,
 ICMP6_MIB_INTIMEEXCDS,
 ICMP6_MIB_INPARMPROBLEMS,
 ICMP6_MIB_INECHOS,
 ICMP6_MIB_INECHOREPLIES,
 ICMP6_MIB_INGROUPMEMBQUERIES,
 ICMP6_MIB_INGROUPMEMBRESPONSES,
 ICMP6_MIB_INGROUPMEMBREDUCTIONS,
 ICMP6_MIB_INROUTERSOLICITS,
 ICMP6_MIB_INROUTERADVERTISEMENTS,
 ICMP6_MIB_INNEIGHBORSOLICITS,
 ICMP6_MIB_INNEIGHBORADVERTISEMENTS,
 ICMP6_MIB_INREDIRECTS,
 ICMP6_MIB_OUTMSGS,
 ICMP6_MIB_OUTDESTUNREACHS,
 ICMP6_MIB_OUTPKTTOOBIGS,
 ICMP6_MIB_OUTTIMEEXCDS,
 ICMP6_MIB_OUTPARMPROBLEMS,
 ICMP6_MIB_OUTECHOREPLIES,
 ICMP6_MIB_OUTROUTERSOLICITS,
 ICMP6_MIB_OUTNEIGHBORSOLICITS,
 ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS,
 ICMP6_MIB_OUTREDIRECTS,
 ICMP6_MIB_OUTGROUPMEMBRESPONSES,
 ICMP6_MIB_OUTGROUPMEMBREDUCTIONS,
 __ICMP6_MIB_MAX
};






enum
{
 TCP_MIB_NUM = 0,
 TCP_MIB_RTOALGORITHM,
 TCP_MIB_RTOMIN,
 TCP_MIB_RTOMAX,
 TCP_MIB_MAXCONN,
 TCP_MIB_ACTIVEOPENS,
 TCP_MIB_PASSIVEOPENS,
 TCP_MIB_ATTEMPTFAILS,
 TCP_MIB_ESTABRESETS,
 TCP_MIB_CURRESTAB,
 TCP_MIB_INSEGS,
 TCP_MIB_OUTSEGS,
 TCP_MIB_RETRANSSEGS,
 TCP_MIB_INERRS,
 TCP_MIB_OUTRSTS,
 __TCP_MIB_MAX
};






enum
{
 UDP_MIB_NUM = 0,
 UDP_MIB_INDATAGRAMS,
 UDP_MIB_NOPORTS,
 UDP_MIB_INERRORS,
 UDP_MIB_OUTDATAGRAMS,
 UDP_MIB_RCVBUFERRORS,
 UDP_MIB_SNDBUFERRORS,
 __UDP_MIB_MAX
};


enum
{
 LINUX_MIB_NUM = 0,
 LINUX_MIB_SYNCOOKIESSENT,
 LINUX_MIB_SYNCOOKIESRECV,
 LINUX_MIB_SYNCOOKIESFAILED,
 LINUX_MIB_EMBRYONICRSTS,
 LINUX_MIB_PRUNECALLED,
 LINUX_MIB_RCVPRUNED,
 LINUX_MIB_OFOPRUNED,
 LINUX_MIB_OUTOFWINDOWICMPS,
 LINUX_MIB_LOCKDROPPEDICMPS,
 LINUX_MIB_ARPFILTER,
 LINUX_MIB_TIMEWAITED,
 LINUX_MIB_TIMEWAITRECYCLED,
 LINUX_MIB_TIMEWAITKILLED,
 LINUX_MIB_PAWSPASSIVEREJECTED,
 LINUX_MIB_PAWSACTIVEREJECTED,
 LINUX_MIB_PAWSESTABREJECTED,
 LINUX_MIB_DELAYEDACKS,
 LINUX_MIB_DELAYEDACKLOCKED,
 LINUX_MIB_DELAYEDACKLOST,
 LINUX_MIB_LISTENOVERFLOWS,
 LINUX_MIB_LISTENDROPS,
 LINUX_MIB_TCPPREQUEUED,
 LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG,
 LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE,
 LINUX_MIB_TCPPREQUEUEDROPPED,
 LINUX_MIB_TCPHPHITS,
 LINUX_MIB_TCPHPHITSTOUSER,
 LINUX_MIB_TCPPUREACKS,
 LINUX_MIB_TCPHPACKS,
 LINUX_MIB_TCPRENORECOVERY,
 LINUX_MIB_TCPSACKRECOVERY,
 LINUX_MIB_TCPSACKRENEGING,
 LINUX_MIB_TCPFACKREORDER,
 LINUX_MIB_TCPSACKREORDER,
 LINUX_MIB_TCPRENOREORDER,
 LINUX_MIB_TCPTSREORDER,
 LINUX_MIB_TCPFULLUNDO,
 LINUX_MIB_TCPPARTIALUNDO,
 LINUX_MIB_TCPDSACKUNDO,
 LINUX_MIB_TCPLOSSUNDO,
 LINUX_MIB_TCPLOSS,
 LINUX_MIB_TCPLOSTRETRANSMIT,
 LINUX_MIB_TCPRENOFAILURES,
 LINUX_MIB_TCPSACKFAILURES,
 LINUX_MIB_TCPLOSSFAILURES,
 LINUX_MIB_TCPFASTRETRANS,
 LINUX_MIB_TCPFORWARDRETRANS,
 LINUX_MIB_TCPSLOWSTARTRETRANS,
 LINUX_MIB_TCPTIMEOUTS,
 LINUX_MIB_TCPRENORECOVERYFAIL,
 LINUX_MIB_TCPSACKRECOVERYFAIL,
 LINUX_MIB_TCPSCHEDULERFAILED,
 LINUX_MIB_TCPRCVCOLLAPSED,
 LINUX_MIB_TCPDSACKOLDSENT,
 LINUX_MIB_TCPDSACKOFOSENT,
 LINUX_MIB_TCPDSACKRECV,
 LINUX_MIB_TCPDSACKOFORECV,
 LINUX_MIB_TCPABORTONSYN,
 LINUX_MIB_TCPABORTONDATA,
 LINUX_MIB_TCPABORTONCLOSE,
 LINUX_MIB_TCPABORTONMEMORY,
 LINUX_MIB_TCPABORTONTIMEOUT,
 LINUX_MIB_TCPABORTONLINGER,
 LINUX_MIB_TCPABORTFAILED,
 LINUX_MIB_TCPMEMORYPRESSURES,
 __LINUX_MIB_MAX
};
# 26 "include/net/snmp.h" 2
# 35 "include/net/snmp.h"
struct snmp_mib {
 char *name;
 int entry;
};
# 73 "include/net/snmp.h"
struct ipstats_mib {
 unsigned long mibs[__IPSTATS_MIB_MAX];
} ;





struct icmp_mib {
 unsigned long mibs[(__ICMP_MIB_MAX + 1)];
} ;



struct icmpv6_mib {
 unsigned long mibs[__ICMP6_MIB_MAX];
} ;



struct tcp_mib {
 unsigned long mibs[__TCP_MIB_MAX];
} ;



struct udp_mib {
 unsigned long mibs[__UDP_MIB_MAX];
} ;



struct linux_mib {
 unsigned long mibs[__LINUX_MIB_MAX];
};
# 68 "net/ipv4/ip_output.c" 2
# 1 "include/net/ip.h" 1
# 26 "include/net/ip.h"
# 1 "include/linux/ip.h" 1
# 85 "include/linux/ip.h"
struct iphdr {

 __u8 ihl:4,
  version:4;






 __u8 tos;
 __be16 tot_len;
 __be16 id;
 __be16 frag_off;
 __u8 ttl;
 __u8 protocol;
 __be16 check;
 __be32 saddr;
 __be32 daddr;

};

struct ip_auth_hdr {
 __u8 nexthdr;
 __u8 hdrlen;
 __be16 reserved;
 __be32 spi;
 __be32 seq_no;
 __u8 auth_data[0];
};

struct ip_esp_hdr {
 __be32 spi;
 __be32 seq_no;
 __u8 enc_data[0];
};

struct ip_comp_hdr {
 __u8 nexthdr;
 __u8 flags;
 __be16 cpi;
};

struct ip_beet_phdr {
 __u8 nexthdr;
 __u8 hdrlen;
 __u8 padlen;
 __u8 reserved;
};
# 27 "include/net/ip.h" 2


# 1 "include/net/inet_sock.h" 1
# 23 "include/net/inet_sock.h"
# 1 "include/net/flow.h" 1
# 10 "include/net/flow.h"
# 1 "include/linux/in6.h" 1
# 30 "include/linux/in6.h"
struct in6_addr
{
 union
 {
  __u8 u6_addr8[16];
  __be16 u6_addr16[8];
  __be32 u6_addr32[4];
 } in6_u;



};
# 51 "include/linux/in6.h"
extern const struct in6_addr in6addr_loopback;


struct sockaddr_in6 {
 unsigned short int sin6_family;
 __be16 sin6_port;
 __u32 sin6_flowinfo;
 struct in6_addr sin6_addr;
 __u32 sin6_scope_id;
};

struct ipv6_mreq {

 struct in6_addr ipv6mr_multiaddr;


 int ipv6mr_ifindex;
};



struct in6_flowlabel_req
{
 struct in6_addr flr_dst;
 __u32 flr_label;
 __u8 flr_action;
 __u8 flr_share;
 __u16 flr_flags;
 __u16 flr_expires;
 __u16 flr_linger;
 __u32 __flr_pad;

};
# 11 "include/net/flow.h" 2


struct flowi {
 int oif;
 int iif;

 union {
  struct {
   __be32 daddr;
   __be32 saddr;
   __u32 fwmark;
   __u8 tos;
   __u8 scope;
  } ip4_u;

  struct {
   struct in6_addr daddr;
   struct in6_addr saddr;
   __u32 fwmark;
   __u32 flowlabel;
  } ip6_u;

  struct {
   __le16 daddr;
   __le16 saddr;
   __u32 fwmark;
   __u8 scope;
  } dn_u;
 } nl_u;
# 54 "include/net/flow.h"
 __u8 proto;
 __u8 flags;

 union {
  struct {
   __be16 sport;
   __be16 dport;
  } ports;

  struct {
   __u8 type;
   __u8 code;
  } icmpt;

  struct {
   __le16 sport;
   __le16 dport;
  } dnports;

  __be32 spi;






 } uli_u;
# 89 "include/net/flow.h"
 __u32 secid;
} __attribute__((__aligned__(32/8)));





struct sock;
typedef int (*flow_resolve_t)(struct flowi *key, u16 family, u8 dir,
          void **objp, atomic_t **obj_refp);

extern void *flow_cache_lookup(struct flowi *key, u16 family, u8 dir,
           flow_resolve_t resolver);
extern void flow_cache_flush(void);
extern atomic_t flow_cache_genid;
# 24 "include/net/inet_sock.h" 2
# 1 "include/net/sock.h" 1
# 50 "include/net/sock.h"
# 1 "include/linux/security.h" 1
# 26 "include/linux/security.h"
# 1 "include/linux/binfmts.h" 1





struct pt_regs;
# 23 "include/linux/binfmts.h"
struct linux_binprm{
 char buf[128];
 struct page *page[32];
 struct mm_struct *mm;
 unsigned long p;
 int sh_bang;
 struct file * file;
 int e_uid, e_gid;
 kernel_cap_t cap_inheritable, cap_permitted, cap_effective;
 void *security;
 int argc, envc;
 char * filename;
 char * interp;


 unsigned interp_flags;
 unsigned interp_data;
 unsigned long loader, exec;
};
# 55 "include/linux/binfmts.h"
struct linux_binfmt {
 struct linux_binfmt * next;
 struct module *module;
 int (*load_binary)(struct linux_binprm *, struct pt_regs * regs);
 int (*load_shlib)(struct file *);
 int (*core_dump)(long signr, struct pt_regs * regs, struct file * file);
 unsigned long min_coredump;
};

extern int register_binfmt(struct linux_binfmt *);
extern int unregister_binfmt(struct linux_binfmt *);

extern int prepare_binprm(struct linux_binprm *);
extern void remove_arg_zero(struct linux_binprm *);
extern int search_binary_handler(struct linux_binprm *,struct pt_regs *);
extern int flush_old_exec(struct linux_binprm * bprm);

extern int suid_dumpable;
# 82 "include/linux/binfmts.h"
extern int setup_arg_pages(struct linux_binprm * bprm,
      unsigned long stack_top,
      int executable_stack);
extern int copy_strings_kernel(int argc,char ** argv,struct linux_binprm *bprm);
extern void compute_creds(struct linux_binprm *binprm);
extern int do_coredump(long signr, int exit_code, struct pt_regs * regs);
extern int set_binfmt(struct linux_binfmt *new);
# 27 "include/linux/security.h" 2



# 1 "include/linux/shm.h" 1
# 19 "include/linux/shm.h"
# 1 "include/asm/shmparam.h" 1
# 20 "include/linux/shm.h" 2


struct shmid_ds {
 struct ipc_perm shm_perm;
 int shm_segsz;
 __kernel_time_t shm_atime;
 __kernel_time_t shm_dtime;
 __kernel_time_t shm_ctime;
 __kernel_ipc_pid_t shm_cpid;
 __kernel_ipc_pid_t shm_lpid;
 unsigned short shm_nattch;
 unsigned short shm_unused;
 void *shm_unused2;
 void *shm_unused3;
};


# 1 "include/asm/shmbuf.h" 1
# 14 "include/asm/shmbuf.h"
struct shmid64_ds {
 struct ipc64_perm shm_perm;
 size_t shm_segsz;
 __kernel_time_t shm_atime;
 unsigned long __unused1;
 __kernel_time_t shm_dtime;
 unsigned long __unused2;
 __kernel_time_t shm_ctime;
 unsigned long __unused3;
 __kernel_pid_t shm_cpid;
 __kernel_pid_t shm_lpid;
 unsigned long shm_nattch;
 unsigned long __unused4;
 unsigned long __unused5;
};

struct shminfo64 {
 unsigned long shmmax;
 unsigned long shmmin;
 unsigned long shmmni;
 unsigned long shmseg;
 unsigned long shmall;
 unsigned long __unused1;
 unsigned long __unused2;
 unsigned long __unused3;
 unsigned long __unused4;
};
# 38 "include/linux/shm.h" 2
# 58 "include/linux/shm.h"
struct shminfo {
 int shmmax;
 int shmmin;
 int shmmni;
 int shmseg;
 int shmall;
};

struct shm_info {
 int used_ids;
 unsigned long shm_tot;
 unsigned long shm_rss;
 unsigned long shm_swp;
 unsigned long swap_attempts;
 unsigned long swap_successes;
};


struct shmid_kernel
{
 struct kern_ipc_perm shm_perm;
 struct file * shm_file;
 int id;
 unsigned long shm_nattch;
 unsigned long shm_segsz;
 time_t shm_atim;
 time_t shm_dtim;
 time_t shm_ctim;
 pid_t shm_cprid;
 pid_t shm_lprid;
 struct user_struct *mlock_user;
};
# 100 "include/linux/shm.h"
static inline __attribute__((always_inline)) long do_shmat(int shmid, char *shmaddr,
    int shmflg, unsigned long *addr)
{
 return -38;
}
# 31 "include/linux/security.h" 2
# 1 "include/linux/msg.h" 1
# 15 "include/linux/msg.h"
struct msqid_ds {
 struct ipc_perm msg_perm;
 struct msg *msg_first;
 struct msg *msg_last;
 __kernel_time_t msg_stime;
 __kernel_time_t msg_rtime;
 __kernel_time_t msg_ctime;
 unsigned long msg_lcbytes;
 unsigned long msg_lqbytes;
 unsigned short msg_cbytes;
 unsigned short msg_qnum;
 unsigned short msg_qbytes;
 __kernel_ipc_pid_t msg_lspid;
 __kernel_ipc_pid_t msg_lrpid;
};


# 1 "include/asm/msgbuf.h" 1
# 14 "include/asm/msgbuf.h"
struct msqid64_ds {
 struct ipc64_perm msg_perm;
 __kernel_time_t msg_stime;
 unsigned long __unused1;
 __kernel_time_t msg_rtime;
 unsigned long __unused2;
 __kernel_time_t msg_ctime;
 unsigned long __unused3;
 unsigned long msg_cbytes;
 unsigned long msg_qnum;
 unsigned long msg_qbytes;
 __kernel_pid_t msg_lspid;
 __kernel_pid_t msg_lrpid;
 unsigned long __unused4;
 unsigned long __unused5;
};
# 33 "include/linux/msg.h" 2


struct msgbuf {
 long mtype;
 char mtext[1];
};


struct msginfo {
 int msgpool;
 int msgmap;
 int msgmax;
 int msgmnb;
 int msgmni;
 int msgssz;
 int msgtql;
 unsigned short msgseg;
};
# 68 "include/linux/msg.h"
struct msg_msg {
 struct list_head m_list;
 long m_type;
 int m_ts;
 struct msg_msgseg* next;
 void *security;

};


struct msg_queue {
 struct kern_ipc_perm q_perm;
 int q_id;
 time_t q_stime;
 time_t q_rtime;
 time_t q_ctime;
 unsigned long q_cbytes;
 unsigned long q_qnum;
 unsigned long q_qbytes;
 pid_t q_lspid;
 pid_t q_lrpid;

 struct list_head q_messages;
 struct list_head q_receivers;
 struct list_head q_senders;
};
# 32 "include/linux/security.h" 2

# 1 "include/linux/key.h" 1
# 27 "include/linux/key.h"
typedef int32_t key_serial_t;


typedef uint32_t key_perm_t;

struct key;
# 381 "include/linux/key.h"
extern struct key root_user_keyring;
extern struct key root_session_keyring;
# 34 "include/linux/security.h" 2
# 1 "include/linux/xfrm.h" 1
# 13 "include/linux/xfrm.h"
typedef union
{
 __be32 a4;
 __be32 a6[4];
} xfrm_address_t;





struct xfrm_id
{
 xfrm_address_t daddr;
 __be32 spi;
 __u8 proto;
};

struct xfrm_sec_ctx {
 __u8 ctx_doi;
 __u8 ctx_alg;
 __u16 ctx_len;
 __u32 ctx_sid;
 char ctx_str[0];
};
# 48 "include/linux/xfrm.h"
struct xfrm_selector
{
 xfrm_address_t daddr;
 xfrm_address_t saddr;
 __be16 dport;
 __be16 dport_mask;
 __be16 sport;
 __be16 sport_mask;
 __u16 family;
 __u8 prefixlen_d;
 __u8 prefixlen_s;
 __u8 proto;
 int ifindex;
 uid_t user;
};



struct xfrm_lifetime_cfg
{
 __u64 soft_byte_limit;
 __u64 hard_byte_limit;
 __u64 soft_packet_limit;
 __u64 hard_packet_limit;
 __u64 soft_add_expires_seconds;
 __u64 hard_add_expires_seconds;
 __u64 soft_use_expires_seconds;
 __u64 hard_use_expires_seconds;
};

struct xfrm_lifetime_cur
{
 __u64 bytes;
 __u64 packets;
 __u64 add_time;
 __u64 use_time;
};

struct xfrm_replay_state
{
 __u32 oseq;
 __u32 seq;
 __u32 bitmap;
};

struct xfrm_algo {
 char alg_name[64];
 int alg_key_len;
 char alg_key[0];
};

struct xfrm_stats {
 __u32 replay_window;
 __u32 replay;
 __u32 integrity_failed;
};

enum
{
 XFRM_POLICY_TYPE_MAIN = 0,
 XFRM_POLICY_TYPE_SUB = 1,
 XFRM_POLICY_TYPE_MAX = 2
};

enum
{
 XFRM_POLICY_IN = 0,
 XFRM_POLICY_OUT = 1,
 XFRM_POLICY_FWD = 2,
 XFRM_POLICY_MAX = 3
};

enum
{
 XFRM_SHARE_ANY,
 XFRM_SHARE_SESSION,
 XFRM_SHARE_USER,
 XFRM_SHARE_UNIQUE
};
# 136 "include/linux/xfrm.h"
enum {
 XFRM_MSG_BASE = 0x10,

 XFRM_MSG_NEWSA = 0x10,

 XFRM_MSG_DELSA,

 XFRM_MSG_GETSA,


 XFRM_MSG_NEWPOLICY,

 XFRM_MSG_DELPOLICY,

 XFRM_MSG_GETPOLICY,


 XFRM_MSG_ALLOCSPI,

 XFRM_MSG_ACQUIRE,

 XFRM_MSG_EXPIRE,


 XFRM_MSG_UPDPOLICY,

 XFRM_MSG_UPDSA,


 XFRM_MSG_POLEXPIRE,


 XFRM_MSG_FLUSHSA,

 XFRM_MSG_FLUSHPOLICY,


 XFRM_MSG_NEWAE,

 XFRM_MSG_GETAE,


 XFRM_MSG_REPORT,


 __XFRM_MSG_MAX
};
# 191 "include/linux/xfrm.h"
struct xfrm_user_sec_ctx {
 __u16 len;
 __u16 exttype;
 __u8 ctx_alg;
 __u8 ctx_doi;
 __u16 ctx_len;
};

struct xfrm_user_tmpl {
 struct xfrm_id id;
 __u16 family;
 xfrm_address_t saddr;
 __u32 reqid;
 __u8 mode;
 __u8 share;
 __u8 optional;
 __u32 aalgos;
 __u32 ealgos;
 __u32 calgos;
};

struct xfrm_encap_tmpl {
 __u16 encap_type;
 __u16 encap_sport;
 __u16 encap_dport;
 xfrm_address_t encap_oa;
};


enum xfrm_ae_ftype_t {
 XFRM_AE_UNSPEC,
 XFRM_AE_RTHR=1,
 XFRM_AE_RVAL=2,
 XFRM_AE_LVAL=4,
 XFRM_AE_ETHR=8,
 XFRM_AE_CR=16,
 XFRM_AE_CE=32,
 XFRM_AE_CU=64,
 __XFRM_AE_MAX


};

struct xfrm_userpolicy_type {
 __u8 type;
 __u16 reserved1;
 __u8 reserved2;
};


enum xfrm_attr_type_t {
 XFRMA_UNSPEC,
 XFRMA_ALG_AUTH,
 XFRMA_ALG_CRYPT,
 XFRMA_ALG_COMP,
 XFRMA_ENCAP,
 XFRMA_TMPL,
 XFRMA_SA,
 XFRMA_POLICY,
 XFRMA_SEC_CTX,
 XFRMA_LTIME_VAL,
 XFRMA_REPLAY_VAL,
 XFRMA_REPLAY_THRESH,
 XFRMA_ETIMER_THRESH,
 XFRMA_SRCADDR,
 XFRMA_COADDR,
 XFRMA_LASTUSED,
 XFRMA_POLICY_TYPE,
 __XFRMA_MAX


};

struct xfrm_usersa_info {
 struct xfrm_selector sel;
 struct xfrm_id id;
 xfrm_address_t saddr;
 struct xfrm_lifetime_cfg lft;
 struct xfrm_lifetime_cur curlft;
 struct xfrm_stats stats;
 __u32 seq;
 __u32 reqid;
 __u16 family;
 __u8 mode;
 __u8 replay_window;
 __u8 flags;




};

struct xfrm_usersa_id {
 xfrm_address_t daddr;
 __be32 spi;
 __u16 family;
 __u8 proto;
};

struct xfrm_aevent_id {
 struct xfrm_usersa_id sa_id;
 __u32 flags;
};

struct xfrm_userspi_info {
 struct xfrm_usersa_info info;
 __u32 min;
 __u32 max;
};

struct xfrm_userpolicy_info {
 struct xfrm_selector sel;
 struct xfrm_lifetime_cfg lft;
 struct xfrm_lifetime_cur curlft;
 __u32 priority;
 __u32 index;
 __u8 dir;
 __u8 action;


 __u8 flags;

 __u8 share;
};

struct xfrm_userpolicy_id {
 struct xfrm_selector sel;
 __u32 index;
 __u8 dir;
};

struct xfrm_user_acquire {
 struct xfrm_id id;
 xfrm_address_t saddr;
 struct xfrm_selector sel;
 struct xfrm_userpolicy_info policy;
 __u32 aalgos;
 __u32 ealgos;
 __u32 calgos;
 __u32 seq;
};

struct xfrm_user_expire {
 struct xfrm_usersa_info state;
 __u8 hard;
};

struct xfrm_user_polexpire {
 struct xfrm_userpolicy_info pol;
 __u8 hard;
};

struct xfrm_usersa_flush {
 __u8 proto;
};

struct xfrm_user_report {
 __u8 proto;
 struct xfrm_selector sel;
};
# 361 "include/linux/xfrm.h"
enum xfrm_nlgroups {
 XFRMNLGRP_NONE,

 XFRMNLGRP_ACQUIRE,

 XFRMNLGRP_EXPIRE,

 XFRMNLGRP_SA,

 XFRMNLGRP_POLICY,

 XFRMNLGRP_AEVENTS,

 XFRMNLGRP_REPORT,

 __XFRMNLGRP_MAX
};
# 35 "include/linux/security.h" 2


struct ctl_table;





extern int cap_capable (struct task_struct *tsk, int cap);
extern int cap_settime (struct timespec *ts, struct timezone *tz);
extern int cap_ptrace (struct task_struct *parent, struct task_struct *child);
extern int cap_capget (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
extern int cap_capset_check (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
extern void cap_capset_set (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
extern int cap_bprm_set_security (struct linux_binprm *bprm);
extern void cap_bprm_apply_creds (struct linux_binprm *bprm, int unsafe);
extern int cap_bprm_secureexec(struct linux_binprm *bprm);
extern int cap_inode_setxattr(struct dentry *dentry, char *name, void *value, size_t size, int flags);
extern int cap_inode_removexattr(struct dentry *dentry, char *name);
extern int cap_task_post_setuid (uid_t old_ruid, uid_t old_euid, uid_t old_suid, int flags);
extern void cap_task_reparent_to_init (struct task_struct *p);
extern int cap_syslog (int type);
extern int cap_vm_enough_memory (long pages);

struct msghdr;
struct sk_buff;
struct sock;
struct sockaddr;
struct socket;
struct flowi;
struct dst_entry;
struct xfrm_selector;
struct xfrm_policy;
struct xfrm_state;
struct xfrm_user_sec_ctx;

extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb);
extern int cap_netlink_recv(struct sk_buff *skb, int cap);
# 90 "include/linux/security.h"
struct nfsctl_arg;
struct sched_param;
struct swap_info_struct;
struct request_sock;
# 2154 "include/linux/security.h"
static inline __attribute__((always_inline)) int security_init(void)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_ptrace (struct task_struct *parent, struct task_struct * child)
{
 return cap_ptrace (parent, child);
}

static inline __attribute__((always_inline)) int security_capget (struct task_struct *target,
       kernel_cap_t *effective,
       kernel_cap_t *inheritable,
       kernel_cap_t *permitted)
{
 return cap_capget (target, effective, inheritable, permitted);
}

static inline __attribute__((always_inline)) int security_capset_check (struct task_struct *target,
      kernel_cap_t *effective,
      kernel_cap_t *inheritable,
      kernel_cap_t *permitted)
{
 return cap_capset_check (target, effective, inheritable, permitted);
}

static inline __attribute__((always_inline)) void security_capset_set (struct task_struct *target,
     kernel_cap_t *effective,
     kernel_cap_t *inheritable,
     kernel_cap_t *permitted)
{
 cap_capset_set (target, effective, inheritable, permitted);
}

static inline __attribute__((always_inline)) int security_capable(struct task_struct *tsk, int cap)
{
 return cap_capable(tsk, cap);
}

static inline __attribute__((always_inline)) int security_acct (struct file *file)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sysctl(struct ctl_table *table, int op)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_quotactl (int cmds, int type, int id,
         struct super_block * sb)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_quota_on (struct dentry * dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_syslog(int type)
{
 return cap_syslog(type);
}

static inline __attribute__((always_inline)) int security_settime(struct timespec *ts, struct timezone *tz)
{
 return cap_settime(ts, tz);
}

static inline __attribute__((always_inline)) int security_vm_enough_memory(long pages)
{
 return cap_vm_enough_memory(pages);
}

static inline __attribute__((always_inline)) int security_bprm_alloc (struct linux_binprm *bprm)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_bprm_free (struct linux_binprm *bprm)
{ }

static inline __attribute__((always_inline)) void security_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
{
 cap_bprm_apply_creds (bprm, unsafe);
}

static inline __attribute__((always_inline)) void security_bprm_post_apply_creds (struct linux_binprm *bprm)
{
 return;
}

static inline __attribute__((always_inline)) int security_bprm_set (struct linux_binprm *bprm)
{
 return cap_bprm_set_security (bprm);
}

static inline __attribute__((always_inline)) int security_bprm_check (struct linux_binprm *bprm)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_bprm_secureexec (struct linux_binprm *bprm)
{
 return cap_bprm_secureexec(bprm);
}

static inline __attribute__((always_inline)) int security_sb_alloc (struct super_block *sb)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_sb_free (struct super_block *sb)
{ }

static inline __attribute__((always_inline)) int security_sb_copy_data (struct file_system_type *type,
      void *orig, void *copy)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sb_kern_mount (struct super_block *sb, void *data)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sb_statfs (struct dentry *dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sb_mount (char *dev_name, struct nameidata *nd,
        char *type, unsigned long flags,
        void *data)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sb_check_sb (struct vfsmount *mnt,
     struct nameidata *nd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sb_umount (struct vfsmount *mnt, int flags)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_sb_umount_close (struct vfsmount *mnt)
{ }

static inline __attribute__((always_inline)) void security_sb_umount_busy (struct vfsmount *mnt)
{ }

static inline __attribute__((always_inline)) void security_sb_post_remount (struct vfsmount *mnt,
          unsigned long flags, void *data)
{ }

static inline __attribute__((always_inline)) void security_sb_post_mountroot (void)
{ }

static inline __attribute__((always_inline)) void security_sb_post_addmount (struct vfsmount *mnt,
           struct nameidata *mountpoint_nd)
{ }

static inline __attribute__((always_inline)) int security_sb_pivotroot (struct nameidata *old_nd,
      struct nameidata *new_nd)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_sb_post_pivotroot (struct nameidata *old_nd,
            struct nameidata *new_nd)
{ }

static inline __attribute__((always_inline)) int security_inode_alloc (struct inode *inode)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_inode_free (struct inode *inode)
{ }

static inline __attribute__((always_inline)) int security_inode_init_security (struct inode *inode,
      struct inode *dir,
      char **name,
      void **value,
      size_t *len)
{
 return -95;
}

static inline __attribute__((always_inline)) int security_inode_create (struct inode *dir,
      struct dentry *dentry,
      int mode)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_link (struct dentry *old_dentry,
           struct inode *dir,
           struct dentry *new_dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_unlink (struct inode *dir,
      struct dentry *dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_symlink (struct inode *dir,
       struct dentry *dentry,
       const char *old_name)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_mkdir (struct inode *dir,
     struct dentry *dentry,
     int mode)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_rmdir (struct inode *dir,
     struct dentry *dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_mknod (struct inode *dir,
     struct dentry *dentry,
     int mode, dev_t dev)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_rename (struct inode *old_dir,
      struct dentry *old_dentry,
      struct inode *new_dir,
      struct dentry *new_dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_readlink (struct dentry *dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_follow_link (struct dentry *dentry,
           struct nameidata *nd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_permission (struct inode *inode, int mask,
          struct nameidata *nd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_setattr (struct dentry *dentry,
       struct iattr *attr)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_getattr (struct vfsmount *mnt,
       struct dentry *dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_inode_delete (struct inode *inode)
{ }

static inline __attribute__((always_inline)) int security_inode_setxattr (struct dentry *dentry, char *name,
        void *value, size_t size, int flags)
{
 return cap_inode_setxattr(dentry, name, value, size, flags);
}

static inline __attribute__((always_inline)) void security_inode_post_setxattr (struct dentry *dentry, char *name,
       void *value, size_t size, int flags)
{ }

static inline __attribute__((always_inline)) int security_inode_getxattr (struct dentry *dentry, char *name)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_listxattr (struct dentry *dentry)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_inode_removexattr (struct dentry *dentry, char *name)
{
 return cap_inode_removexattr(dentry, name);
}

static inline __attribute__((always_inline)) const char *security_inode_xattr_getsuffix (void)
{
 return ((void *)0) ;
}

static inline __attribute__((always_inline)) int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
{
 return -95;
}

static inline __attribute__((always_inline)) int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
{
 return -95;
}

static inline __attribute__((always_inline)) int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_permission (struct file *file, int mask)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_alloc (struct file *file)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_file_free (struct file *file)
{ }

static inline __attribute__((always_inline)) int security_file_ioctl (struct file *file, unsigned int cmd,
           unsigned long arg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_mmap (struct file *file, unsigned long reqprot,
          unsigned long prot,
          unsigned long flags)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_mprotect (struct vm_area_struct *vma,
       unsigned long reqprot,
       unsigned long prot)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_lock (struct file *file, unsigned int cmd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_fcntl (struct file *file, unsigned int cmd,
           unsigned long arg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_set_fowner (struct file *file)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_send_sigiotask (struct task_struct *tsk,
      struct fown_struct *fown,
      int sig)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_file_receive (struct file *file)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_create (unsigned long clone_flags)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_alloc (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_task_free (struct task_struct *p)
{ }

static inline __attribute__((always_inline)) int security_task_setuid (uid_t id0, uid_t id1, uid_t id2,
     int flags)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_post_setuid (uid_t old_ruid, uid_t old_euid,
          uid_t old_suid, int flags)
{
 return cap_task_post_setuid (old_ruid, old_euid, old_suid, flags);
}

static inline __attribute__((always_inline)) int security_task_setgid (gid_t id0, gid_t id1, gid_t id2,
     int flags)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_setpgid (struct task_struct *p, pid_t pgid)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_getpgid (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_getsid (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_task_getsecid (struct task_struct *p, u32 *secid)
{ }

static inline __attribute__((always_inline)) int security_task_setgroups (struct group_info *group_info)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_setnice (struct task_struct *p, int nice)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_setioprio (struct task_struct *p, int ioprio)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_getioprio (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_setrlimit (unsigned int resource,
        struct rlimit *new_rlim)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_setscheduler (struct task_struct *p,
           int policy,
           struct sched_param *lp)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_getscheduler (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_movememory (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_kill (struct task_struct *p,
          struct siginfo *info, int sig,
          u32 secid)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_wait (struct task_struct *p)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_task_prctl (int option, unsigned long arg2,
           unsigned long arg3,
           unsigned long arg4,
           unsigned long arg5)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_task_reparent_to_init (struct task_struct *p)
{
 cap_task_reparent_to_init (p);
}

static inline __attribute__((always_inline)) void security_task_to_inode(struct task_struct *p, struct inode *inode)
{ }

static inline __attribute__((always_inline)) int security_ipc_permission (struct kern_ipc_perm *ipcp,
        short flag)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_msg_msg_alloc (struct msg_msg * msg)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_msg_msg_free (struct msg_msg * msg)
{ }

static inline __attribute__((always_inline)) int security_msg_queue_alloc (struct msg_queue *msq)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_msg_queue_free (struct msg_queue *msq)
{ }

static inline __attribute__((always_inline)) int security_msg_queue_associate (struct msg_queue * msq,
      int msqflg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_msg_queue_msgctl (struct msg_queue * msq, int cmd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_msg_queue_msgsnd (struct msg_queue * msq,
          struct msg_msg * msg, int msqflg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_msg_queue_msgrcv (struct msg_queue * msq,
          struct msg_msg * msg,
          struct task_struct * target,
          long type, int mode)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_shm_alloc (struct shmid_kernel *shp)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_shm_free (struct shmid_kernel *shp)
{ }

static inline __attribute__((always_inline)) int security_shm_associate (struct shmid_kernel * shp,
       int shmflg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_shm_shmctl (struct shmid_kernel * shp, int cmd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_shm_shmat (struct shmid_kernel * shp,
          char *shmaddr, int shmflg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sem_alloc (struct sem_array *sma)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_sem_free (struct sem_array *sma)
{ }

static inline __attribute__((always_inline)) int security_sem_associate (struct sem_array * sma, int semflg)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sem_semctl (struct sem_array * sma, int cmd)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_sem_semop (struct sem_array * sma,
          struct sembuf * sops, unsigned nsops,
          int alter)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_d_instantiate (struct dentry *dentry, struct inode *inode)
{ }

static inline __attribute__((always_inline)) int security_getprocattr(struct task_struct *p, char *name, void *value, size_t size)
{
 return -22;
}

static inline __attribute__((always_inline)) int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
{
 return -22;
}

static inline __attribute__((always_inline)) int security_netlink_send (struct sock *sk, struct sk_buff *skb)
{
 return cap_netlink_send (sk, skb);
}

static inline __attribute__((always_inline)) int security_netlink_recv (struct sk_buff *skb, int cap)
{
 return cap_netlink_recv (skb, cap);
}

static inline __attribute__((always_inline)) struct dentry *securityfs_create_dir(const char *name,
     struct dentry *parent)
{
 return ERR_PTR(-19);
}

static inline __attribute__((always_inline)) struct dentry *securityfs_create_file(const char *name,
      mode_t mode,
      struct dentry *parent,
      void *data,
      struct file_operations *fops)
{
 return ERR_PTR(-19);
}

static inline __attribute__((always_inline)) void securityfs_remove(struct dentry *dentry)
{
}

static inline __attribute__((always_inline)) int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
 return -95;
}

static inline __attribute__((always_inline)) void security_release_secctx(char *secdata, u32 seclen)
{
}
# 2970 "include/linux/security.h"
static inline __attribute__((always_inline)) int security_unix_stream_connect(struct socket * sock,
            struct socket * other,
            struct sock * newsk)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_unix_may_send(struct socket * sock,
      struct socket * other)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_create (int family, int type,
       int protocol, int kern)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_post_create(struct socket * sock,
           int family,
           int type,
           int protocol, int kern)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_bind(struct socket * sock,
           struct sockaddr * address,
           int addrlen)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_connect(struct socket * sock,
       struct sockaddr * address,
       int addrlen)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_listen(struct socket * sock, int backlog)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_accept(struct socket * sock,
      struct socket * newsock)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_socket_post_accept(struct socket * sock,
            struct socket * newsock)
{
}

static inline __attribute__((always_inline)) int security_socket_sendmsg(struct socket * sock,
       struct msghdr * msg, int size)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_recvmsg(struct socket * sock,
       struct msghdr * msg, int size,
       int flags)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_getsockname(struct socket * sock)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_getpeername(struct socket * sock)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_getsockopt(struct socket * sock,
          int level, int optname)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_setsockopt(struct socket * sock,
          int level, int optname)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_shutdown(struct socket * sock, int how)
{
 return 0;
}
static inline __attribute__((always_inline)) int security_sock_rcv_skb (struct sock * sk,
      struct sk_buff * skb)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_socket_getpeersec_stream(struct socket *sock, char *optval,
          int *optlen, unsigned len)
{
 return -92;
}

static inline __attribute__((always_inline)) int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
{
 return -92;
}

static inline __attribute__((always_inline)) int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_sk_free(struct sock *sk)
{
}

static inline __attribute__((always_inline)) void security_sk_clone(const struct sock *sk, struct sock *newsk)
{
}

static inline __attribute__((always_inline)) void security_sk_classify_flow(struct sock *sk, struct flowi *fl)
{
}

static inline __attribute__((always_inline)) void security_req_classify_flow(const struct request_sock *req, struct flowi *fl)
{
}

static inline __attribute__((always_inline)) void security_sock_graft(struct sock* sk, struct socket *parent)
{
}

static inline __attribute__((always_inline)) int security_inet_conn_request(struct sock *sk,
   struct sk_buff *skb, struct request_sock *req)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_inet_csk_clone(struct sock *newsk,
   const struct request_sock *req)
{
}
# 3194 "include/linux/security.h"
static inline __attribute__((always_inline)) int security_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_xfrm_policy_free(struct xfrm_policy *xp)
{
}

static inline __attribute__((always_inline)) int security_xfrm_policy_delete(struct xfrm_policy *xp)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_xfrm_state_alloc(struct xfrm_state *x,
     struct xfrm_user_sec_ctx *sec_ctx)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
     struct xfrm_sec_ctx *polsec, u32 secid)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_xfrm_state_free(struct xfrm_state *x)
{
}

static inline __attribute__((always_inline)) int security_xfrm_state_delete(struct xfrm_state *x)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_xfrm_policy_lookup(struct xfrm_policy *xp, u32 fl_secid, u8 dir)
{
 return 0;
}

static inline __attribute__((always_inline)) int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
   struct xfrm_policy *xp, struct flowi *fl)
{
 return 1;
}

static inline __attribute__((always_inline)) int security_xfrm_flow_state_match(struct flowi *fl,
   struct xfrm_state *xfrm, struct xfrm_policy *xp)
{
 return 1;
}

static inline __attribute__((always_inline)) int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid)
{
 return 0;
}

static inline __attribute__((always_inline)) void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl)
{
}
# 51 "include/net/sock.h" 2

# 1 "include/linux/filter.h" 1
# 26 "include/linux/filter.h"
struct sock_filter
{
 __u16 code;
 __u8 jt;
 __u8 jf;
 __u32 k;
};

struct sock_fprog
{
 unsigned short len;
 struct sock_filter *filter;
};


struct sk_filter
{
 atomic_t refcnt;
 unsigned int len;
 struct rcu_head rcu;
 struct sock_filter insns[0];
};

static inline __attribute__((always_inline)) unsigned int sk_filter_len(struct sk_filter *fp)
{
 return fp->len*sizeof(struct sock_filter) + sizeof(*fp);
}
# 144 "include/linux/filter.h"
struct sk_buff;
struct sock;

extern unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen);
extern int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
extern int sk_chk_filter(struct sock_filter *filter, int flen);
# 53 "include/net/sock.h" 2


# 1 "include/net/dst.h" 1
# 12 "include/net/dst.h"
# 1 "include/linux/rtnetlink.h" 1



# 1 "include/linux/netlink.h" 1
# 29 "include/linux/netlink.h"
struct sockaddr_nl
{
 sa_family_t nl_family;
 unsigned short nl_pad;
 __u32 nl_pid;
        __u32 nl_groups;
};

struct nlmsghdr
{
 __u32 nlmsg_len;
 __u16 nlmsg_type;
 __u16 nlmsg_flags;
 __u32 nlmsg_seq;
 __u32 nlmsg_pid;
};
# 94 "include/linux/netlink.h"
struct nlmsgerr
{
 int error;
 struct nlmsghdr msg;
};





struct nl_pktinfo
{
 __u32 group;
};



enum {
 NETLINK_UNCONNECTED = 0,
 NETLINK_CONNECTED,
};
# 125 "include/linux/netlink.h"
struct nlattr
{
 __u16 nla_len;
 __u16 nla_type;
};
# 140 "include/linux/netlink.h"
struct netlink_skb_parms
{
 struct ucred creds;
 __u32 pid;
 __u32 dst_pid;
 __u32 dst_group;
 kernel_cap_t eff_cap;
 __u32 loginuid;
 __u32 sid;
};





extern struct sock *netlink_kernel_create(int unit, unsigned int groups, void (*input)(struct sock *sk, int len), struct module *module);
extern void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err);
extern int netlink_has_listeners(struct sock *sk, unsigned int group);
extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 pid, int nonblock);
extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 pid,
        __u32 group, gfp_t allocation);
extern void netlink_set_err(struct sock *ssk, __u32 pid, __u32 group, int code);
extern int netlink_register_notifier(struct notifier_block *nb);
extern int netlink_unregister_notifier(struct notifier_block *nb);


struct sock *netlink_getsockbyfilp(struct file *filp);
int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
  long timeo, struct sock *ssk);
void netlink_detachskb(struct sock *sk, struct sk_buff *skb);
int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol);
# 179 "include/linux/netlink.h"
struct netlink_callback
{
 struct sk_buff *skb;
 struct nlmsghdr *nlh;
 int (*dump)(struct sk_buff * skb, struct netlink_callback *cb);
 int (*done)(struct netlink_callback *cb);
 int family;
 long args[5];
};

struct netlink_notify
{
 int pid;
 int protocol;
};

static __inline__ __attribute__((always_inline)) struct nlmsghdr *
__nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
{
 struct nlmsghdr *nlh;
 int size = ((len)+( ((((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )))+4 -1) & ~(4 -1) ));

 nlh = (struct nlmsghdr*)skb_put(skb, ( ((size)+4 -1) & ~(4 -1) ));
 nlh->nlmsg_type = type;
 nlh->nlmsg_len = size;
 nlh->nlmsg_flags = flags;
 nlh->nlmsg_pid = pid;
 nlh->nlmsg_seq = seq;
 memset(((void*)(((char*)nlh) + ((0)+( ((((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )))+4 -1) & ~(4 -1) )))) + len, 0, ( ((size)+4 -1) & ~(4 -1) ) - size);
 return nlh;
}
# 231 "include/linux/netlink.h"
extern int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
         struct nlmsghdr *nlh,
         int (*dump)(struct sk_buff *skb, struct netlink_callback*),
         int (*done)(struct netlink_callback*));




extern void netlink_set_nonroot(int protocol, unsigned flag);
# 5 "include/linux/rtnetlink.h" 2
# 1 "include/linux/if_link.h" 1






struct rtnl_link_stats
{
 __u32 rx_packets;
 __u32 tx_packets;
 __u32 rx_bytes;
 __u32 tx_bytes;
 __u32 rx_errors;
 __u32 tx_errors;
 __u32 rx_dropped;
 __u32 tx_dropped;
 __u32 multicast;
 __u32 collisions;


 __u32 rx_length_errors;
 __u32 rx_over_errors;
 __u32 rx_crc_errors;
 __u32 rx_frame_errors;
 __u32 rx_fifo_errors;
 __u32 rx_missed_errors;


 __u32 tx_aborted_errors;
 __u32 tx_carrier_errors;
 __u32 tx_fifo_errors;
 __u32 tx_heartbeat_errors;
 __u32 tx_window_errors;


 __u32 rx_compressed;
 __u32 tx_compressed;
};


struct rtnl_link_ifmap
{
 __u64 mem_start;
 __u64 mem_end;
 __u64 base_addr;
 __u16 irq;
 __u8 dma;
 __u8 port;
};

enum
{
 IFLA_UNSPEC,
 IFLA_ADDRESS,
 IFLA_BROADCAST,
 IFLA_IFNAME,
 IFLA_MTU,
 IFLA_LINK,
 IFLA_QDISC,
 IFLA_STATS,
 IFLA_COST,

 IFLA_PRIORITY,

 IFLA_MASTER,

 IFLA_WIRELESS,

 IFLA_PROTINFO,

 IFLA_TXQLEN,

 IFLA_MAP,

 IFLA_WEIGHT,

 IFLA_OPERSTATE,
 IFLA_LINKMODE,
 __IFLA_MAX
};
# 121 "include/linux/if_link.h"
enum
{
 IFLA_INET6_UNSPEC,
 IFLA_INET6_FLAGS,
 IFLA_INET6_CONF,
 IFLA_INET6_STATS,
 IFLA_INET6_MCAST,
 IFLA_INET6_CACHEINFO,
 __IFLA_INET6_MAX
};



struct ifla_cacheinfo
{
 __u32 max_reasm_len;
 __u32 tstamp;
 __u32 reachable_time;
 __u32 retrans_time;
};
# 6 "include/linux/rtnetlink.h" 2
# 1 "include/linux/if_addr.h" 1





struct ifaddrmsg
{
 __u8 ifa_family;
 __u8 ifa_prefixlen;
 __u8 ifa_flags;
 __u8 ifa_scope;
 __u32 ifa_index;
};
# 22 "include/linux/if_addr.h"
enum
{
 IFA_UNSPEC,
 IFA_ADDRESS,
 IFA_LOCAL,
 IFA_LABEL,
 IFA_BROADCAST,
 IFA_ANYCAST,
 IFA_CACHEINFO,
 IFA_MULTICAST,
 __IFA_MAX,
};
# 47 "include/linux/if_addr.h"
struct ifa_cacheinfo
{
 __u32 ifa_prefered;
 __u32 ifa_valid;
 __u32 cstamp;
 __u32 tstamp;
};
# 7 "include/linux/rtnetlink.h" 2
# 1 "include/linux/neighbour.h" 1





struct ndmsg
{
 __u8 ndm_family;
 __u8 ndm_pad1;
 __u16 ndm_pad2;
 __s32 ndm_ifindex;
 __u16 ndm_state;
 __u8 ndm_flags;
 __u8 ndm_type;
};

enum
{
 NDA_UNSPEC,
 NDA_DST,
 NDA_LLADDR,
 NDA_CACHEINFO,
 NDA_PROBES,
 __NDA_MAX
};
# 57 "include/linux/neighbour.h"
struct nda_cacheinfo
{
 __u32 ndm_confirmed;
 __u32 ndm_used;
 __u32 ndm_updated;
 __u32 ndm_refcnt;
};
# 90 "include/linux/neighbour.h"
struct ndt_stats
{
 __u64 ndts_allocs;
 __u64 ndts_destroys;
 __u64 ndts_hash_grows;
 __u64 ndts_res_failed;
 __u64 ndts_lookups;
 __u64 ndts_hits;
 __u64 ndts_rcv_probes_mcast;
 __u64 ndts_rcv_probes_ucast;
 __u64 ndts_periodic_gc_runs;
 __u64 ndts_forced_gc_runs;
};

enum {
 NDTPA_UNSPEC,
 NDTPA_IFINDEX,
 NDTPA_REFCNT,
 NDTPA_REACHABLE_TIME,
 NDTPA_BASE_REACHABLE_TIME,
 NDTPA_RETRANS_TIME,
 NDTPA_GC_STALETIME,
 NDTPA_DELAY_PROBE_TIME,
 NDTPA_QUEUE_LEN,
 NDTPA_APP_PROBES,
 NDTPA_UCAST_PROBES,
 NDTPA_MCAST_PROBES,
 NDTPA_ANYCAST_DELAY,
 NDTPA_PROXY_DELAY,
 NDTPA_PROXY_QLEN,
 NDTPA_LOCKTIME,
 __NDTPA_MAX
};


struct ndtmsg
{
 __u8 ndtm_family;
 __u8 ndtm_pad1;
 __u16 ndtm_pad2;
};

struct ndt_config
{
 __u16 ndtc_key_len;
 __u16 ndtc_entry_size;
 __u32 ndtc_entries;
 __u32 ndtc_last_flush;
 __u32 ndtc_last_rand;
 __u32 ndtc_hash_rnd;
 __u32 ndtc_hash_mask;
 __u32 ndtc_hash_chain_gc;
 __u32 ndtc_proxy_qlen;
};

enum {
 NDTA_UNSPEC,
 NDTA_NAME,
 NDTA_THRESH1,
 NDTA_THRESH2,
 NDTA_THRESH3,
 NDTA_CONFIG,
 NDTA_PARMS,
 NDTA_STATS,
 NDTA_GC_INTERVAL,
 __NDTA_MAX
};
# 8 "include/linux/rtnetlink.h" 2







enum {
 RTM_BASE = 16,


 RTM_NEWLINK = 16,

 RTM_DELLINK,

 RTM_GETLINK,

 RTM_SETLINK,


 RTM_NEWADDR = 20,

 RTM_DELADDR,

 RTM_GETADDR,


 RTM_NEWROUTE = 24,

 RTM_DELROUTE,

 RTM_GETROUTE,


 RTM_NEWNEIGH = 28,

 RTM_DELNEIGH,

 RTM_GETNEIGH,


 RTM_NEWRULE = 32,

 RTM_DELRULE,

 RTM_GETRULE,


 RTM_NEWQDISC = 36,

 RTM_DELQDISC,

 RTM_GETQDISC,


 RTM_NEWTCLASS = 40,

 RTM_DELTCLASS,

 RTM_GETTCLASS,


 RTM_NEWTFILTER = 44,

 RTM_DELTFILTER,

 RTM_GETTFILTER,


 RTM_NEWACTION = 48,

 RTM_DELACTION,

 RTM_GETACTION,


 RTM_NEWPREFIX = 52,

 RTM_GETPREFIX = 54,


 RTM_GETMULTICAST = 58,


 RTM_GETANYCAST = 62,


 RTM_NEWNEIGHTBL = 64,

 RTM_GETNEIGHTBL = 66,

 RTM_SETNEIGHTBL,


 __RTM_MAX,

};
# 116 "include/linux/rtnetlink.h"
struct rtattr
{
 unsigned short rta_len;
 unsigned short rta_type;
};
# 143 "include/linux/rtnetlink.h"
struct rtmsg
{
 unsigned char rtm_family;
 unsigned char rtm_dst_len;
 unsigned char rtm_src_len;
 unsigned char rtm_tos;

 unsigned char rtm_table;
 unsigned char rtm_protocol;
 unsigned char rtm_scope;
 unsigned char rtm_type;

 unsigned rtm_flags;
};



enum
{
 RTN_UNSPEC,
 RTN_UNICAST,
 RTN_LOCAL,
 RTN_BROADCAST,

 RTN_ANYCAST,

 RTN_MULTICAST,
 RTN_BLACKHOLE,
 RTN_UNREACHABLE,
 RTN_PROHIBIT,
 RTN_THROW,
 RTN_NAT,
 RTN_XRESOLVE,
 __RTN_MAX
};
# 218 "include/linux/rtnetlink.h"
enum rt_scope_t
{
 RT_SCOPE_UNIVERSE=0,

 RT_SCOPE_SITE=200,
 RT_SCOPE_LINK=253,
 RT_SCOPE_HOST=254,
 RT_SCOPE_NOWHERE=255
};
# 237 "include/linux/rtnetlink.h"
enum rt_class_t
{
 RT_TABLE_UNSPEC=0,

 RT_TABLE_DEFAULT=253,
 RT_TABLE_MAIN=254,
 RT_TABLE_LOCAL=255,
 RT_TABLE_MAX=0xFFFFFFFF
};




enum rtattr_type_t
{
 RTA_UNSPEC,
 RTA_DST,
 RTA_SRC,
 RTA_IIF,
 RTA_OIF,
 RTA_GATEWAY,
 RTA_PRIORITY,
 RTA_PREFSRC,
 RTA_METRICS,
 RTA_MULTIPATH,
 RTA_PROTOINFO,
 RTA_FLOW,
 RTA_CACHEINFO,
 RTA_SESSION,
 RTA_MP_ALGO,
 RTA_TABLE,
 __RTA_MAX
};
# 285 "include/linux/rtnetlink.h"
struct rtnexthop
{
 unsigned short rtnh_len;
 unsigned char rtnh_flags;
 unsigned char rtnh_hops;
 int rtnh_ifindex;
};
# 312 "include/linux/rtnetlink.h"
struct rta_cacheinfo
{
 __u32 rta_clntref;
 __u32 rta_lastuse;
 __s32 rta_expires;
 __u32 rta_error;
 __u32 rta_used;


 __u32 rta_id;
 __u32 rta_ts;
 __u32 rta_tsage;
};



enum
{
 RTAX_UNSPEC,

 RTAX_LOCK,

 RTAX_MTU,

 RTAX_WINDOW,

 RTAX_RTT,

 RTAX_RTTVAR,

 RTAX_SSTHRESH,

 RTAX_CWND,

 RTAX_ADVMSS,

 RTAX_REORDERING,

 RTAX_HOPLIMIT,

 RTAX_INITCWND,

 RTAX_FEATURES,

 __RTAX_MAX
};
# 366 "include/linux/rtnetlink.h"
struct rta_session
{
 __u8 proto;
 __u8 pad1;
 __u16 pad2;

 union {
  struct {
   __u16 sport;
   __u16 dport;
  } ports;

  struct {
   __u8 type;
   __u8 code;
   __u16 ident;
  } icmpt;

  __u32 spi;
 } u;
};





struct rtgenmsg
{
 unsigned char rtgen_family;
};
# 406 "include/linux/rtnetlink.h"
struct ifinfomsg
{
 unsigned char ifi_family;
 unsigned char __ifi_pad;
 unsigned short ifi_type;
 int ifi_index;
 unsigned ifi_flags;
 unsigned ifi_change;
};





struct prefixmsg
{
 unsigned char prefix_family;
 unsigned char prefix_pad1;
 unsigned short prefix_pad2;
 int prefix_ifindex;
 unsigned char prefix_type;
 unsigned char prefix_len;
 unsigned char prefix_flags;
 unsigned char prefix_pad3;
};

enum
{
 PREFIX_UNSPEC,
 PREFIX_ADDRESS,
 PREFIX_CACHEINFO,
 __PREFIX_MAX
};



struct prefix_cacheinfo
{
 __u32 preferred_time;
 __u32 valid_time;
};






struct tcmsg
{
 unsigned char tcm_family;
 unsigned char tcm__pad1;
 unsigned short tcm__pad2;
 int tcm_ifindex;
 __u32 tcm_handle;
 __u32 tcm_parent;
 __u32 tcm_info;
};

enum
{
 TCA_UNSPEC,
 TCA_KIND,
 TCA_OPTIONS,
 TCA_STATS,
 TCA_XSTATS,
 TCA_RATE,
 TCA_FCNT,
 TCA_STATS2,
 __TCA_MAX
};
# 506 "include/linux/rtnetlink.h"
enum rtnetlink_groups {
 RTNLGRP_NONE,

 RTNLGRP_LINK,

 RTNLGRP_NOTIFY,

 RTNLGRP_NEIGH,

 RTNLGRP_TC,

 RTNLGRP_IPV4_IFADDR,

 RTNLGRP_IPV4_MROUTE,

 RTNLGRP_IPV4_ROUTE,

 RTNLGRP_IPV4_RULE,

 RTNLGRP_IPV6_IFADDR,

 RTNLGRP_IPV6_MROUTE,

 RTNLGRP_IPV6_ROUTE,

 RTNLGRP_IPV6_IFINFO,

 RTNLGRP_DECnet_IFADDR,

 RTNLGRP_NOP2,
 RTNLGRP_DECnet_ROUTE,

 RTNLGRP_DECnet_RULE,

 RTNLGRP_NOP4,
 RTNLGRP_IPV6_PREFIX,

 RTNLGRP_IPV6_RULE,

 __RTNLGRP_MAX
};



struct tcamsg
{
 unsigned char tca_family;
 unsigned char tca__pad1;
 unsigned short tca__pad2;
};
# 567 "include/linux/rtnetlink.h"
extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
static __inline__ __attribute__((always_inline)) int rtattr_strcmp(const struct rtattr *rta, const char *str)
{
 int len = strlen(str) + 1;
 return len > rta->rta_len || memcmp(((void*)(((char*)(rta)) + (( ((sizeof(struct rtattr))+4 -1) & ~(4 -1) ) + (0)))), str, len);
}

extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);




struct rtnetlink_link
{
 int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
 int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
};

extern struct rtnetlink_link * rtnetlink_links[32];
extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
extern int rtnl_unicast(struct sk_buff *skb, u32 pid);
extern int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group,
         struct nlmsghdr *nlh, gfp_t flags);
extern void rtnl_set_sk_err(u32 group, int error);
extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);

extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
# 679 "include/linux/rtnetlink.h"
static inline __attribute__((always_inline)) struct rtattr *
__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
{
 struct rtattr *rta;
 int size = (( ((sizeof(struct rtattr))+4 -1) & ~(4 -1) ) + (attrlen));

 rta = (struct rtattr*)skb_put(skb, ( ((size)+4 -1) & ~(4 -1) ));
 rta->rta_type = attrtype;
 rta->rta_len = size;
 memset(((void*)(((char*)(rta)) + (( ((sizeof(struct rtattr))+4 -1) & ~(4 -1) ) + (0)))) + attrlen, 0, ( ((size)+4 -1) & ~(4 -1) ) - size);
 return rta;
}






extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);


extern void rtnl_lock(void);
extern void rtnl_unlock(void);
extern int rtnl_trylock(void);

extern void rtnetlink_init(void);
extern void __rtnl_unlock(void);
# 723 "include/linux/rtnetlink.h"
static inline __attribute__((always_inline)) u32 rtm_get_table(struct rtattr **rta, u8 table)
{
 return ({ if (!rta[RTA_TABLE-1] || ((int)((rta[RTA_TABLE-1])->rta_len) - (( ((sizeof(struct rtattr))+4 -1) & ~(4 -1) ) + (0))) < sizeof(u32)) goto rtattr_failure; *(u32 *) ((void*)(((char*)(rta[RTA_TABLE-1])) + (( ((sizeof(struct rtattr))+4 -1) & ~(4 -1) ) + (0)))); });
rtattr_failure:
 return table;
}
# 13 "include/net/dst.h" 2


# 1 "include/net/neighbour.h" 1
# 23 "include/net/neighbour.h"
# 1 "include/linux/seq_file.h" 1
# 9 "include/linux/seq_file.h"
struct seq_operations;
struct file;
struct vfsmount;
struct dentry;
struct inode;

struct seq_file {
 char *buf;
 size_t size;
 size_t from;
 size_t count;
 loff_t index;
 loff_t version;
 struct mutex lock;
 struct seq_operations *op;
 void *private;
};

struct seq_operations {
 void * (*start) (struct seq_file *m, loff_t *pos);
 void (*stop) (struct seq_file *m, void *v);
 void * (*next) (struct seq_file *m, void *v, loff_t *pos);
 int (*show) (struct seq_file *m, void *v);
};

int seq_open(struct file *, struct seq_operations *);
ssize_t seq_read(struct file *, char *, size_t, loff_t *);
loff_t seq_lseek(struct file *, loff_t, int);
int seq_release(struct inode *, struct file *);
int seq_escape(struct seq_file *, const char *, const char *);
int seq_putc(struct seq_file *m, char c);
int seq_puts(struct seq_file *m, const char *s);

int seq_printf(struct seq_file *, const char *, ...)
 __attribute__ ((format (printf,2,3)));

int seq_path(struct seq_file *, struct vfsmount *, struct dentry *, char *);

int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
int single_release(struct inode *, struct file *);
int seq_release_private(struct inode *, struct file *);
# 24 "include/net/neighbour.h" 2
# 32 "include/net/neighbour.h"
struct neighbour;

struct neigh_parms
{
 struct net_device *dev;
 struct neigh_parms *next;
 int (*neigh_setup)(struct neighbour *);
 void (*neigh_destructor)(struct neighbour *);
 struct neigh_table *tbl;

 void *sysctl_table;

 int dead;
 atomic_t refcnt;
 struct rcu_head rcu_head;

 int base_reachable_time;
 int retrans_time;
 int gc_staletime;
 int reachable_time;
 int delay_probe_time;

 int queue_len;
 int ucast_probes;
 int app_probes;
 int mcast_probes;
 int anycast_delay;
 int proxy_delay;
 int proxy_qlen;
 int locktime;
};

struct neigh_statistics
{
 unsigned long allocs;
 unsigned long destroys;
 unsigned long hash_grows;

 unsigned long res_failed;

 unsigned long lookups;
 unsigned long hits;

 unsigned long rcv_probes_mcast;
 unsigned long rcv_probes_ucast;

 unsigned long periodic_gc_runs;
 unsigned long forced_gc_runs;
};
# 89 "include/net/neighbour.h"
struct neighbour
{
 struct neighbour *next;
 struct neigh_table *tbl;
 struct neigh_parms *parms;
 struct net_device *dev;
 unsigned long used;
 unsigned long confirmed;
 unsigned long updated;
 __u8 flags;
 __u8 nud_state;
 __u8 type;
 __u8 dead;
 atomic_t probes;
 rwlock_t lock;
 unsigned char ha[(((32)+((typeof(32))(sizeof(unsigned long))-1))&~((typeof(32))(sizeof(unsigned long))-1))];
 struct hh_cache *hh;
 atomic_t refcnt;
 int (*output)(struct sk_buff *skb);
 struct sk_buff_head arp_queue;
 struct timer_list timer;
 struct neigh_ops *ops;
 u8 primary_key[0];
};

struct neigh_ops
{
 int family;
 void (*solicit)(struct neighbour *, struct sk_buff*);
 void (*error_report)(struct neighbour *, struct sk_buff*);
 int (*output)(struct sk_buff*);
 int (*connected_output)(struct sk_buff*);
 int (*hh_output)(struct sk_buff*);
 int (*queue_xmit)(struct sk_buff*);
};

struct pneigh_entry
{
 struct pneigh_entry *next;
 struct net_device *dev;
 u8 flags;
 u8 key[0];
};






struct neigh_table
{
 struct neigh_table *next;
 int family;
 int entry_size;
 int key_len;
 __u32 (*hash)(const void *pkey, const struct net_device *);
 int (*constructor)(struct neighbour *);
 int (*pconstructor)(struct pneigh_entry *);
 void (*pdestructor)(struct pneigh_entry *);
 void (*proxy_redo)(struct sk_buff *skb);
 char *id;
 struct neigh_parms parms;

 int gc_interval;
 int gc_thresh1;
 int gc_thresh2;
 int gc_thresh3;
 unsigned long last_flush;
 struct timer_list gc_timer;
 struct timer_list proxy_timer;
 struct sk_buff_head proxy_queue;
 atomic_t entries;
 rwlock_t lock;
 unsigned long last_rand;
 kmem_cache_t *kmem_cachep;
 struct neigh_statistics *stats;
 struct neighbour **hash_buckets;
 unsigned int hash_mask;
 __u32 hash_rnd;
 unsigned int hash_chain_gc;
 struct pneigh_entry **phash_buckets;

 struct proc_dir_entry *pde;

};
# 182 "include/net/neighbour.h"
extern void neigh_table_init(struct neigh_table *tbl);
extern void neigh_table_init_no_netlink(struct neigh_table *tbl);
extern int neigh_table_clear(struct neigh_table *tbl);
extern struct neighbour * neigh_lookup(struct neigh_table *tbl,
          const void *pkey,
          struct net_device *dev);
extern struct neighbour * neigh_lookup_nodev(struct neigh_table *tbl,
         const void *pkey);
extern struct neighbour * neigh_create(struct neigh_table *tbl,
          const void *pkey,
          struct net_device *dev);
extern void neigh_destroy(struct neighbour *neigh);
extern int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
extern int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
          u32 flags);
extern void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
extern int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
extern int neigh_resolve_output(struct sk_buff *skb);
extern int neigh_connected_output(struct sk_buff *skb);
extern int neigh_compat_output(struct sk_buff *skb);
extern struct neighbour *neigh_event_ns(struct neigh_table *tbl,
      u8 *lladdr, void *saddr,
      struct net_device *dev);

extern struct neigh_parms *neigh_parms_alloc(struct net_device *dev, struct neigh_table *tbl);
extern void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
extern void neigh_parms_destroy(struct neigh_parms *parms);
extern unsigned long neigh_rand_reach_time(unsigned long base);

extern void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
            struct sk_buff *skb);
extern struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, const void *key, struct net_device *dev, int creat);
extern int pneigh_delete(struct neigh_table *tbl, const void *key, struct net_device *dev);

struct netlink_callback;
struct nlmsghdr;
extern int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb);
extern int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
extern int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
extern void neigh_app_ns(struct neighbour *n);

extern int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb);
extern int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);

extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie);
extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *));
extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *));

struct neigh_seq_state {
 struct neigh_table *tbl;
 void *(*neigh_sub_iter)(struct neigh_seq_state *state,
    struct neighbour *n, loff_t *pos);
 unsigned int bucket;
 unsigned int flags;



};
extern void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, unsigned int);
extern void *neigh_seq_next(struct seq_file *, void *, loff_t *);
extern void neigh_seq_stop(struct seq_file *, void *);

extern int neigh_sysctl_register(struct net_device *dev,
            struct neigh_parms *p,
            int p_id, int pdev_id,
            char *p_name,
            proc_handler *proc_handler,
            ctl_handler *strategy);
extern void neigh_sysctl_unregister(struct neigh_parms *p);

static inline __attribute__((always_inline)) void __neigh_parms_put(struct neigh_parms *parms)
{
 atomic_dec(&parms->refcnt);
}

static inline __attribute__((always_inline)) void neigh_parms_put(struct neigh_parms *parms)
{
 if ((atomic_sub_return(1, (&parms->refcnt)) == 0))
  neigh_parms_destroy(parms);
}

static inline __attribute__((always_inline)) struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms)
{
 atomic_inc(&parms->refcnt);
 return parms;
}





static inline __attribute__((always_inline)) void neigh_release(struct neighbour *neigh)
{
 if ((atomic_sub_return(1, (&neigh->refcnt)) == 0))
  neigh_destroy(neigh);
}

static inline __attribute__((always_inline)) struct neighbour * neigh_clone(struct neighbour *neigh)
{
 if (neigh)
  atomic_inc(&neigh->refcnt);
 return neigh;
}



static inline __attribute__((always_inline)) void neigh_confirm(struct neighbour *neigh)
{
 if (neigh)
  neigh->confirmed = jiffies;
}

static inline __attribute__((always_inline)) int neigh_is_connected(struct neighbour *neigh)
{
 return neigh->nud_state&(0x80|0x40|0x02);
}

static inline __attribute__((always_inline)) int neigh_is_valid(struct neighbour *neigh)
{
 return neigh->nud_state&(0x80|0x40|0x02|0x10|0x04|0x08);
}

static inline __attribute__((always_inline)) int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
{
 neigh->used = jiffies;
 if (!(neigh->nud_state&((0x80|0x40|0x02)|0x08|0x10)))
  return __neigh_event_send(neigh, skb);
 return 0;
}

static inline __attribute__((always_inline)) struct neighbour *
__neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
{
 struct neighbour *n = neigh_lookup(tbl, pkey, dev);

 if (n || !creat)
  return n;

 n = neigh_create(tbl, pkey, dev);
 return IS_ERR(n) ? ((void *)0) : n;
}

static inline __attribute__((always_inline)) struct neighbour *
__neigh_lookup_errno(struct neigh_table *tbl, const void *pkey,
  struct net_device *dev)
{
 struct neighbour *n = neigh_lookup(tbl, pkey, dev);

 if (n)
  return n;

 return neigh_create(tbl, pkey, dev);
}

struct neighbour_cb {
 unsigned long sched_next;
 unsigned int flags;
};
# 16 "include/net/dst.h" 2
# 36 "include/net/dst.h"
struct sk_buff;

struct dst_entry
{
 struct dst_entry *next;
 atomic_t __refcnt;
 int __use;
 struct dst_entry *child;
 struct net_device *dev;
 short error;
 short obsolete;
 int flags;





 unsigned long lastuse;
 unsigned long expires;

 unsigned short header_len;
 unsigned short nfheader_len;
 unsigned short trailer_len;

 u32 metrics[(__RTAX_MAX - 1)];
 struct dst_entry *path;

 unsigned long rate_last;
 unsigned long rate_tokens;

 struct neighbour *neighbour;
 struct hh_cache *hh;
 struct xfrm_state *xfrm;

 int (*input)(struct sk_buff*);
 int (*output)(struct sk_buff*);





 struct dst_ops *ops;
 struct rcu_head rcu_head;

 char info[0];
};


struct dst_ops
{
 unsigned short family;
 __be16 protocol;
 unsigned gc_thresh;

 int (*gc)(void);
 struct dst_entry * (*check)(struct dst_entry *, __u32 cookie);
 void (*destroy)(struct dst_entry *);
 void (*ifdown)(struct dst_entry *,
       struct net_device *dev, int how);
 struct dst_entry * (*negative_advice)(struct dst_entry *);
 void (*link_failure)(struct sk_buff *);
 void (*update_pmtu)(struct dst_entry *dst, u32 mtu);
 int entry_size;

 atomic_t entries;
 kmem_cache_t *kmem_cachep;
};



static inline __attribute__((always_inline)) u32
dst_metric(const struct dst_entry *dst, int metric)
{
 return dst->metrics[metric-1];
}

static inline __attribute__((always_inline)) u32 dst_mtu(const struct dst_entry *dst)
{
 u32 mtu = dst_metric(dst, RTAX_MTU);



 __asm__ __volatile__("": : :"memory");
 return mtu;
}

static inline __attribute__((always_inline)) u32
dst_allfrag(const struct dst_entry *dst)
{
 int ret = dst_metric(dst, RTAX_FEATURES) & 0x00000008;

 __asm__ __volatile__("": : :"memory");
 return ret;
}

static inline __attribute__((always_inline)) int
dst_metric_locked(struct dst_entry *dst, int metric)
{
 return dst_metric(dst, RTAX_LOCK) & (1<<metric);
}

static inline __attribute__((always_inline)) void dst_hold(struct dst_entry * dst)
{
 atomic_inc(&dst->__refcnt);
}

static inline __attribute__((always_inline))
struct dst_entry * dst_clone(struct dst_entry * dst)
{
 if (dst)
  atomic_inc(&dst->__refcnt);
 return dst;
}

static inline __attribute__((always_inline))
void dst_release(struct dst_entry * dst)
{
 if (dst) {
  ({ typeof(((&dst->__refcnt)->counter) < 1) __ret_warn_on = (((&dst->__refcnt)->counter) < 1); if (__builtin_expect(!!(__ret_warn_on), 0)) { printk("BUG: warning at %s:%d/%s()\n", "include/net/dst.h", 154, (__func__)); dump_stack(); } __builtin_expect(!!(__ret_warn_on), 0); });
  __asm__ __volatile__("": : :"memory");
  atomic_dec(&dst->__refcnt);
 }
}





static inline __attribute__((always_inline)) struct dst_entry *dst_pop(struct dst_entry *dst)
{
 struct dst_entry *child = dst_clone(dst->child);

 dst_release(dst);
 return child;
}

extern void * dst_alloc(struct dst_ops * ops);
extern void __dst_free(struct dst_entry * dst);
extern struct dst_entry *dst_destroy(struct dst_entry * dst);

static inline __attribute__((always_inline)) void dst_free(struct dst_entry * dst)
{
 if (dst->obsolete > 1)
  return;
 if (!((&dst->__refcnt)->counter)) {
  dst = dst_destroy(dst);
  if (!dst)
   return;
 }
 __dst_free(dst);
}

static inline __attribute__((always_inline)) void dst_rcu_free(struct rcu_head *head)
{
 struct dst_entry *dst = ({ const typeof( ((struct dst_entry *)0)->rcu_head ) *__mptr = (head); (struct dst_entry *)( (char *)__mptr - __builtin_offsetof(struct dst_entry,rcu_head) );});
 dst_free(dst);
}

static inline __attribute__((always_inline)) void dst_confirm(struct dst_entry *dst)
{
 if (dst)
  neigh_confirm(dst->neighbour);
}

static inline __attribute__((always_inline)) void dst_negative_advice(struct dst_entry **dst_p)
{
 struct dst_entry * dst = *dst_p;
 if (dst && dst->ops->negative_advice)
  *dst_p = dst->ops->negative_advice(dst);
}

static inline __attribute__((always_inline)) void dst_link_failure(struct sk_buff *skb)
{
 struct dst_entry * dst = skb->dst;
 if (dst && dst->ops && dst->ops->link_failure)
  dst->ops->link_failure(skb);
}

static inline __attribute__((always_inline)) void dst_set_expires(struct dst_entry *dst, int timeout)
{
 unsigned long expires = jiffies + timeout;

 if (expires == 0)
  expires = 1;

 if (dst->expires == 0 || (({ unsigned long __dummy; typeof(dst->expires) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(expires) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(expires) - (long)(dst->expires) < 0)))
  dst->expires = expires;
}


static inline __attribute__((always_inline)) int dst_output(struct sk_buff *skb)
{
 return skb->dst->output(skb);
}


static inline __attribute__((always_inline)) int dst_input(struct sk_buff *skb)
{
 int err;

 for (;;) {
  err = skb->dst->input(skb);

  if (__builtin_expect(!!(err == 0), 1))
   return err;

  if (__builtin_expect(!!(err != 4), 0))
   return err;
 }
}

static inline __attribute__((always_inline)) struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
{
 if (dst->obsolete)
  dst = dst->ops->check(dst, cookie);
 return dst;
}

extern void dst_init(void);

struct flowi;

static inline __attribute__((always_inline)) int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
         struct sock *sk, int flags)
{
 return 0;
}
# 56 "include/net/sock.h" 2
# 77 "include/net/sock.h"
struct sock_iocb;
typedef struct {
 spinlock_t slock;
 struct sock_iocb *owner;
 wait_queue_head_t wq;
# 91 "include/net/sock.h"
} socket_lock_t;

struct sock;
struct proto;
# 111 "include/net/sock.h"
struct sock_common {
 unsigned short skc_family;
 volatile unsigned char skc_state;
 unsigned char skc_reuse;
 int skc_bound_dev_if;
 struct hlist_node skc_node;
 struct hlist_node skc_bind_node;
 atomic_t skc_refcnt;
 unsigned int skc_hash;
 struct proto *skc_prot;
};
# 182 "include/net/sock.h"
struct sock {




 struct sock_common __sk_common;
# 197 "include/net/sock.h"
 unsigned char sk_shutdown : 2,
    sk_no_check : 2,
    sk_userlocks : 4;
 unsigned char sk_protocol;
 unsigned short sk_type;
 int sk_rcvbuf;
 socket_lock_t sk_lock;
 wait_queue_head_t *sk_sleep;
 struct dst_entry *sk_dst_cache;
 struct xfrm_policy *sk_policy[2];
 rwlock_t sk_dst_lock;
 atomic_t sk_rmem_alloc;
 atomic_t sk_wmem_alloc;
 atomic_t sk_omem_alloc;
 struct sk_buff_head sk_receive_queue;
 struct sk_buff_head sk_write_queue;
 struct sk_buff_head sk_async_wait_queue;
 int sk_wmem_queued;
 int sk_forward_alloc;
 gfp_t sk_allocation;
 int sk_sndbuf;
 int sk_route_caps;
 int sk_gso_type;
 int sk_rcvlowat;
 unsigned long sk_flags;
 unsigned long sk_lingertime;





 struct {
  struct sk_buff *head;
  struct sk_buff *tail;
 } sk_backlog;
 struct sk_buff_head sk_error_queue;
 struct proto *sk_prot_creator;
 rwlock_t sk_callback_lock;
 int sk_err,
    sk_err_soft;
 unsigned short sk_ack_backlog;
 unsigned short sk_max_ack_backlog;
 __u32 sk_priority;
 struct ucred sk_peercred;
 long sk_rcvtimeo;
 long sk_sndtimeo;
 struct sk_filter *sk_filter;
 void *sk_protinfo;
 struct timer_list sk_timer;
 struct timeval sk_stamp;
 struct socket *sk_socket;
 void *sk_user_data;
 struct page *sk_sndmsg_page;
 struct sk_buff *sk_send_head;
 __u32 sk_sndmsg_off;
 int sk_write_pending;
 void *sk_security;
 void (*sk_state_change)(struct sock *sk);
 void (*sk_data_ready)(struct sock *sk, int bytes);
 void (*sk_write_space)(struct sock *sk);
 void (*sk_error_report)(struct sock *sk);
   int (*sk_backlog_rcv)(struct sock *sk,
        struct sk_buff *skb);
 void (*sk_destruct)(struct sock *sk);
};




static inline __attribute__((always_inline)) struct sock *__sk_head(const struct hlist_head *head)
{
 return ({ const typeof( ((struct sock *)0)->__sk_common.skc_node ) *__mptr = (head->first); (struct sock *)( (char *)__mptr - __builtin_offsetof(struct sock,__sk_common.skc_node) );});
}

static inline __attribute__((always_inline)) struct sock *sk_head(const struct hlist_head *head)
{
 return hlist_empty(head) ? ((void *)0) : __sk_head(head);
}

static inline __attribute__((always_inline)) struct sock *sk_next(const struct sock *sk)
{
 return sk->__sk_common.skc_node.next ?
  ({ const typeof( ((struct sock *)0)->__sk_common.skc_node ) *__mptr = (sk->__sk_common.skc_node.next); (struct sock *)( (char *)__mptr - __builtin_offsetof(struct sock,__sk_common.skc_node) );}) : ((void *)0);
}

static inline __attribute__((always_inline)) int sk_unhashed(const struct sock *sk)
{
 return hlist_unhashed(&sk->__sk_common.skc_node);
}

static inline __attribute__((always_inline)) int sk_hashed(const struct sock *sk)
{
 return !sk_unhashed(sk);
}

static __inline__ __attribute__((always_inline)) void sk_node_init(struct hlist_node *node)
{
 node->pprev = ((void *)0);
}

static __inline__ __attribute__((always_inline)) void __sk_del_node(struct sock *sk)
{
 __hlist_del(&sk->__sk_common.skc_node);
}

static __inline__ __attribute__((always_inline)) int __sk_del_node_init(struct sock *sk)
{
 if (sk_hashed(sk)) {
  __sk_del_node(sk);
  sk_node_init(&sk->__sk_common.skc_node);
  return 1;
 }
 return 0;
}







static inline __attribute__((always_inline)) void sock_hold(struct sock *sk)
{
 atomic_inc(&sk->__sk_common.skc_refcnt);
}




static inline __attribute__((always_inline)) void __sock_put(struct sock *sk)
{
 atomic_dec(&sk->__sk_common.skc_refcnt);
}

static __inline__ __attribute__((always_inline)) int sk_del_node_init(struct sock *sk)
{
 int rc = __sk_del_node_init(sk);

 if (rc) {

  ({ typeof(((&sk->__sk_common.skc_refcnt)->counter) == 1) __ret_warn_on = (((&sk->__sk_common.skc_refcnt)->counter) == 1); if (__builtin_expect(!!(__ret_warn_on), 0)) { printk("BUG: warning at %s:%d/%s()\n", "include/net/sock.h", 337, (__func__)); dump_stack(); } __builtin_expect(!!(__ret_warn_on), 0); });
  __sock_put(sk);
 }
 return rc;
}

static __inline__ __attribute__((always_inline)) void __sk_add_node(struct sock *sk, struct hlist_head *list)
{
 hlist_add_head(&sk->__sk_common.skc_node, list);
}

static __inline__ __attribute__((always_inline)) void sk_add_node(struct sock *sk, struct hlist_head *list)
{
 sock_hold(sk);
 __sk_add_node(sk, list);
}

static __inline__ __attribute__((always_inline)) void __sk_del_bind_node(struct sock *sk)
{
 __hlist_del(&sk->__sk_common.skc_bind_node);
}

static __inline__ __attribute__((always_inline)) void sk_add_bind_node(struct sock *sk,
     struct hlist_head *list)
{
 hlist_add_head(&sk->__sk_common.skc_bind_node, list);
}
# 379 "include/net/sock.h"
enum sock_flags {
 SOCK_DEAD,
 SOCK_DONE,
 SOCK_URGINLINE,
 SOCK_KEEPOPEN,
 SOCK_LINGER,
 SOCK_DESTROY,
 SOCK_BROADCAST,
 SOCK_TIMESTAMP,
 SOCK_ZAPPED,
 SOCK_USE_WRITE_QUEUE,
 SOCK_DBG,
 SOCK_RCVTSTAMP,
 SOCK_LOCALROUTE,
 SOCK_QUEUE_SHRUNK,
};

static inline __attribute__((always_inline)) void sock_copy_flags(struct sock *nsk, struct sock *osk)
{
 nsk->sk_flags = osk->sk_flags;
}

static inline __attribute__((always_inline)) void sock_set_flag(struct sock *sk, enum sock_flags flag)
{
 __set_bit(flag, &sk->sk_flags);
}

static inline __attribute__((always_inline)) void sock_reset_flag(struct sock *sk, enum sock_flags flag)
{
 __clear_bit(flag, &sk->sk_flags);
}

static inline __attribute__((always_inline)) int sock_flag(struct sock *sk, enum sock_flags flag)
{
 return (__builtin_constant_p(flag) ? __constant_test_bit((flag),(&sk->sk_flags)) : __test_bit((flag),(&sk->sk_flags)));
}

static inline __attribute__((always_inline)) void sk_acceptq_removed(struct sock *sk)
{
 sk->sk_ack_backlog--;
}

static inline __attribute__((always_inline)) void sk_acceptq_added(struct sock *sk)
{
 sk->sk_ack_backlog++;
}

static inline __attribute__((always_inline)) int sk_acceptq_is_full(struct sock *sk)
{
 return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
}




static inline __attribute__((always_inline)) int sk_stream_min_wspace(struct sock *sk)
{
 return sk->sk_wmem_queued / 2;
}

static inline __attribute__((always_inline)) int sk_stream_wspace(struct sock *sk)
{
 return sk->sk_sndbuf - sk->sk_wmem_queued;
}

extern void sk_stream_write_space(struct sock *sk);

static inline __attribute__((always_inline)) int sk_stream_memory_free(struct sock *sk)
{
 return sk->sk_wmem_queued < sk->sk_sndbuf;
}

extern void sk_stream_rfree(struct sk_buff *skb);

static inline __attribute__((always_inline)) void sk_stream_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
 skb->sk = sk;
 skb->destructor = sk_stream_rfree;
 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
 sk->sk_forward_alloc -= skb->truesize;
}

static inline __attribute__((always_inline)) void sk_stream_free_skb(struct sock *sk, struct sk_buff *skb)
{
 skb_truesize_check(skb);
 sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
 sk->sk_wmem_queued -= skb->truesize;
 sk->sk_forward_alloc += skb->truesize;
 __kfree_skb(skb);
}


static inline __attribute__((always_inline)) void sk_add_backlog(struct sock *sk, struct sk_buff *skb)
{
 if (!sk->sk_backlog.tail) {
  sk->sk_backlog.head = sk->sk_backlog.tail = skb;
 } else {
  sk->sk_backlog.tail->next = skb;
  sk->sk_backlog.tail = skb;
 }
 skb->next = ((void *)0);
}
# 494 "include/net/sock.h"
extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
extern int sk_stream_error(struct sock *sk, int flags, int err);
extern void sk_stream_kill_queues(struct sock *sk);

extern int sk_wait_data(struct sock *sk, long *timeo);

struct request_sock_ops;
struct timewait_sock_ops;





struct proto {
 void (*close)(struct sock *sk,
     long timeout);
 int (*connect)(struct sock *sk,
            struct sockaddr *uaddr,
     int addr_len);
 int (*disconnect)(struct sock *sk, int flags);

 struct sock * (*accept) (struct sock *sk, int flags, int *err);

 int (*ioctl)(struct sock *sk, int cmd,
      unsigned long arg);
 int (*init)(struct sock *sk);
 int (*destroy)(struct sock *sk);
 void (*shutdown)(struct sock *sk, int how);
 int (*setsockopt)(struct sock *sk, int level,
     int optname, char *optval,
     int optlen);
 int (*getsockopt)(struct sock *sk, int level,
     int optname, char *optval,
     int *option);
 int (*compat_setsockopt)(struct sock *sk,
     int level,
     int optname, char *optval,
     int optlen);
 int (*compat_getsockopt)(struct sock *sk,
     int level,
     int optname, char *optval,
     int *option);
 int (*sendmsg)(struct kiocb *iocb, struct sock *sk,
        struct msghdr *msg, size_t len);
 int (*recvmsg)(struct kiocb *iocb, struct sock *sk,
        struct msghdr *msg,
     size_t len, int noblock, int flags,
     int *addr_len);
 int (*sendpage)(struct sock *sk, struct page *page,
     int offset, size_t size, int flags);
 int (*bind)(struct sock *sk,
     struct sockaddr *uaddr, int addr_len);

 int (*backlog_rcv) (struct sock *sk,
      struct sk_buff *skb);


 void (*hash)(struct sock *sk);
 void (*unhash)(struct sock *sk);
 int (*get_port)(struct sock *sk, unsigned short snum);


 void (*enter_memory_pressure)(void);
 atomic_t *memory_allocated;
 atomic_t *sockets_allocated;






 int *memory_pressure;
 int *sysctl_mem;
 int *sysctl_wmem;
 int *sysctl_rmem;
 int max_header;

 kmem_cache_t *slab;
 unsigned int obj_size;

 atomic_t *orphan_count;

 struct request_sock_ops *rsk_prot;
 struct timewait_sock_ops *twsk_prot;

 struct module *owner;

 char name[32];

 struct list_head node;



 struct {
  int inuse;
  u8 __pad[(1 << 5) - sizeof(int)];
 } stats[1];
};

extern int proto_register(struct proto *prot, int alloc_slab);
extern void proto_unregister(struct proto *prot);
# 624 "include/net/sock.h"
static __inline__ __attribute__((always_inline)) void sock_prot_inc_use(struct proto *prot)
{
 prot->stats[0].inuse++;
}

static __inline__ __attribute__((always_inline)) void sock_prot_dec_use(struct proto *prot)
{
 prot->stats[0].inuse--;
}




static inline __attribute__((always_inline)) void __sk_prot_rehash(struct sock *sk)
{
 sk->__sk_common.skc_prot->unhash(sk);
 sk->__sk_common.skc_prot->hash(sk);
}
# 659 "include/net/sock.h"
struct sock_iocb {
 struct list_head list;

 int flags;
 int size;
 struct socket *sock;
 struct sock *sk;
 struct scm_cookie *scm;
 struct msghdr *msg, async_msg;
 struct kiocb *kiocb;
};

static inline __attribute__((always_inline)) struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
{
 return (struct sock_iocb *)iocb->private;
}

static inline __attribute__((always_inline)) struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
{
 return si->kiocb;
}

struct socket_alloc {
 struct socket socket;
 struct inode vfs_inode;
};

static inline __attribute__((always_inline)) struct socket *SOCKET_I(struct inode *inode)
{
 return &({ const typeof( ((struct socket_alloc *)0)->vfs_inode ) *__mptr = (inode); (struct socket_alloc *)( (char *)__mptr - __builtin_offsetof(struct socket_alloc,vfs_inode) );})->socket;
}

static inline __attribute__((always_inline)) struct inode *SOCK_INODE(struct socket *socket)
{
 return &({ const typeof( ((struct socket_alloc *)0)->socket ) *__mptr = (socket); (struct socket_alloc *)( (char *)__mptr - __builtin_offsetof(struct socket_alloc,socket) );})->vfs_inode;
}

extern void __sk_stream_mem_reclaim(struct sock *sk);
extern int sk_stream_mem_schedule(struct sock *sk, int size, int kind);



static inline __attribute__((always_inline)) int sk_stream_pages(int amt)
{
 return (amt + ((int)(1UL << 12)) - 1) / ((int)(1UL << 12));
}

static inline __attribute__((always_inline)) void sk_stream_mem_reclaim(struct sock *sk)
{
 if (sk->sk_forward_alloc >= ((int)(1UL << 12)))
  __sk_stream_mem_reclaim(sk);
}

static inline __attribute__((always_inline)) void sk_stream_writequeue_purge(struct sock *sk)
{
 struct sk_buff *skb;

 while ((skb = __skb_dequeue(&sk->sk_write_queue)) != ((void *)0))
  sk_stream_free_skb(sk, skb);
 sk_stream_mem_reclaim(sk);
}

static inline __attribute__((always_inline)) int sk_stream_rmem_schedule(struct sock *sk, struct sk_buff *skb)
{
 return (int)skb->truesize <= sk->sk_forward_alloc ||
  sk_stream_mem_schedule(sk, skb->truesize, 1);
}

static inline __attribute__((always_inline)) int sk_stream_wmem_schedule(struct sock *sk, int size)
{
 return size <= sk->sk_forward_alloc ||
        sk_stream_mem_schedule(sk, size, 0);
}
# 748 "include/net/sock.h"
extern void lock_sock(struct sock *sk);
extern void release_sock(struct sock *sk);
# 758 "include/net/sock.h"
extern struct sock *sk_alloc(int family,
       gfp_t priority,
       struct proto *prot, int zero_it);
extern void sk_free(struct sock *sk);
extern struct sock *sk_clone(const struct sock *sk,
       const gfp_t priority);

extern struct sk_buff *sock_wmalloc(struct sock *sk,
           unsigned long size, int force,
           gfp_t priority);
extern struct sk_buff *sock_rmalloc(struct sock *sk,
           unsigned long size, int force,
           gfp_t priority);
extern void sock_wfree(struct sk_buff *skb);
extern void sock_rfree(struct sk_buff *skb);

extern int sock_setsockopt(struct socket *sock, int level,
      int op, char *optval,
      int optlen);

extern int sock_getsockopt(struct socket *sock, int level,
      int op, char *optval,
      int *optlen);
extern struct sk_buff *sock_alloc_send_skb(struct sock *sk,
           unsigned long size,
           int noblock,
           int *errcode);
extern void *sock_kmalloc(struct sock *sk, int size,
     gfp_t priority);
extern void sock_kfree_s(struct sock *sk, void *mem, int size);
extern void sk_send_sigurg(struct sock *sk);





extern int sock_no_bind(struct socket *,
          struct sockaddr *, int);
extern int sock_no_connect(struct socket *,
      struct sockaddr *, int, int);
extern int sock_no_socketpair(struct socket *,
         struct socket *);
extern int sock_no_accept(struct socket *,
            struct socket *, int);
extern int sock_no_getname(struct socket *,
      struct sockaddr *, int *, int);
extern unsigned int sock_no_poll(struct file *, struct socket *,
          struct poll_table_struct *);
extern int sock_no_ioctl(struct socket *, unsigned int,
           unsigned long);
extern int sock_no_listen(struct socket *, int);
extern int sock_no_shutdown(struct socket *, int);
extern int sock_no_getsockopt(struct socket *, int , int,
         char *, int *);
extern int sock_no_setsockopt(struct socket *, int, int,
         char *, int);
extern int sock_no_sendmsg(struct kiocb *, struct socket *,
      struct msghdr *, size_t);
extern int sock_no_recvmsg(struct kiocb *, struct socket *,
      struct msghdr *, size_t, int);
extern int sock_no_mmap(struct file *file,
          struct socket *sock,
          struct vm_area_struct *vma);
extern ssize_t sock_no_sendpage(struct socket *sock,
      struct page *page,
      int offset, size_t size,
      int flags);





extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
      char *optval, int *optlen);
extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
          struct msghdr *msg, size_t size, int flags);
extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
      char *optval, int optlen);
extern int compat_sock_common_getsockopt(struct socket *sock, int level,
  int optname, char *optval, int *optlen);
extern int compat_sock_common_setsockopt(struct socket *sock, int level,
  int optname, char *optval, int optlen);

extern void sk_common_release(struct sock *sk);






extern void sock_init_data(struct socket *sock, struct sock *sk);
# 864 "include/net/sock.h"
static inline __attribute__((always_inline)) int sk_filter(struct sock *sk, struct sk_buff *skb)
{
 int err;
 struct sk_filter *filter;

 err = security_sock_rcv_skb(sk, skb);
 if (err)
  return err;

 do { local_bh_disable(); (void)0; } while(0);
 filter = sk->sk_filter;
 if (filter) {
  unsigned int pkt_len = sk_run_filter(skb, filter->insns,
    filter->len);
  err = pkt_len ? pskb_trim(skb, pkt_len) : -1;
 }
  do { (void)0; local_bh_enable(); } while(0);

 return err;
}





static inline __attribute__((always_inline)) void sk_filter_rcu_free(struct rcu_head *rcu)
{
 struct sk_filter *fp = ({ const typeof( ((struct sk_filter *)0)->rcu ) *__mptr = (rcu); (struct sk_filter *)( (char *)__mptr - __builtin_offsetof(struct sk_filter,rcu) );});
 kfree(fp);
}
# 903 "include/net/sock.h"
static inline __attribute__((always_inline)) void sk_filter_release(struct sock *sk, struct sk_filter *fp)
{
 unsigned int size = sk_filter_len(fp);

 atomic_sub(size, &sk->sk_omem_alloc);

 if ((atomic_sub_return(1, (&fp->refcnt)) == 0))
  call_rcu_bh(&fp->rcu, sk_filter_rcu_free);
}

static inline __attribute__((always_inline)) void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
{
 atomic_inc(&fp->refcnt);
 atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
}
# 945 "include/net/sock.h"
static inline __attribute__((always_inline)) void sock_put(struct sock *sk)
{
 if ((atomic_sub_return(1, (&sk->__sk_common.skc_refcnt)) == 0))
  sk_free(sk);
}

extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb);
# 960 "include/net/sock.h"
static inline __attribute__((always_inline)) void sock_orphan(struct sock *sk)
{
 do { local_bh_disable(); do { do { } while (0); (void)0; (void)(&sk->sk_callback_lock); } while (0); } while (0);
 sock_set_flag(sk, SOCK_DEAD);
 sk->sk_socket = ((void *)0);
 sk->sk_sleep = ((void *)0);
 do { do { } while (0); local_bh_enable(); (void)0; (void)(&sk->sk_callback_lock); } while (0);
}

static inline __attribute__((always_inline)) void sock_graft(struct sock *sk, struct socket *parent)
{
 do { local_bh_disable(); do { do { } while (0); (void)0; (void)(&sk->sk_callback_lock); } while (0); } while (0);
 sk->sk_sleep = &parent->wait;
 parent->sk = sk;
 sk->sk_socket = parent;
 security_sock_graft(sk, parent);
 do { do { } while (0); local_bh_enable(); (void)0; (void)(&sk->sk_callback_lock); } while (0);
}

static inline __attribute__((always_inline)) void sock_copy(struct sock *nsk, const struct sock *osk)
{




 memcpy(nsk, osk, osk->__sk_common.skc_prot->obj_size);




}

extern int sock_i_uid(struct sock *sk);
extern unsigned long sock_i_ino(struct sock *sk);

static inline __attribute__((always_inline)) struct dst_entry *
__sk_dst_get(struct sock *sk)
{
 return sk->sk_dst_cache;
}

static inline __attribute__((always_inline)) struct dst_entry *
sk_dst_get(struct sock *sk)
{
 struct dst_entry *dst;

 do { do { } while (0); (void)0; (void)(&sk->sk_dst_lock); } while (0);
 dst = sk->sk_dst_cache;
 if (dst)
  dst_hold(dst);
 do { do { } while (0); (void)0; (void)(&sk->sk_dst_lock); } while (0);
 return dst;
}

static inline __attribute__((always_inline)) void
__sk_dst_set(struct sock *sk, struct dst_entry *dst)
{
 struct dst_entry *old_dst;

 old_dst = sk->sk_dst_cache;
 sk->sk_dst_cache = dst;
 dst_release(old_dst);
}

static inline __attribute__((always_inline)) void
sk_dst_set(struct sock *sk, struct dst_entry *dst)
{
 do { do { } while (0); (void)0; (void)(&sk->sk_dst_lock); } while (0);
 __sk_dst_set(sk, dst);
 do { do { } while (0); (void)0; (void)(&sk->sk_dst_lock); } while (0);
}

static inline __attribute__((always_inline)) void
__sk_dst_reset(struct sock *sk)
{
 struct dst_entry *old_dst;

 old_dst = sk->sk_dst_cache;
 sk->sk_dst_cache = ((void *)0);
 dst_release(old_dst);
}

static inline __attribute__((always_inline)) void
sk_dst_reset(struct sock *sk)
{
 do { do { } while (0); (void)0; (void)(&sk->sk_dst_lock); } while (0);
 __sk_dst_reset(sk);
 do { do { } while (0); (void)0; (void)(&sk->sk_dst_lock); } while (0);
}

extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);

extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);

static inline __attribute__((always_inline)) int sk_can_gso(const struct sock *sk)
{
 return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
}

static inline __attribute__((always_inline)) void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
{
 __sk_dst_set(sk, dst);
 sk->sk_route_caps = dst->dev->features;
 if (sk->sk_route_caps & 2048)
  sk->sk_route_caps |= 0xffff0000;
 if (sk_can_gso(sk)) {
  if (dst->header_len)
   sk->sk_route_caps &= ~0xffff0000;
  else
   sk->sk_route_caps |= 1 | 8;
 }
}

static inline __attribute__((always_inline)) void sk_charge_skb(struct sock *sk, struct sk_buff *skb)
{
 sk->sk_wmem_queued += skb->truesize;
 sk->sk_forward_alloc -= skb->truesize;
}

static inline __attribute__((always_inline)) int skb_copy_to_page(struct sock *sk, char *from,
       struct sk_buff *skb, struct page *page,
       int off, int copy)
{
 if (skb->ip_summed == 0) {
  int err = 0;
  unsigned int csum = csum_and_copy_from_user(from,
           lowmem_page_address(page) + off,
           copy, 0, &err);
  if (err)
   return err;
  skb->csum = csum_block_add(skb->csum, csum, skb->len);
 } else if (copy_from_user(lowmem_page_address(page) + off, from, copy))
  return -14;

 skb->len += copy;
 skb->data_len += copy;
 skb->truesize += copy;
 sk->sk_wmem_queued += copy;
 sk->sk_forward_alloc -= copy;
 return 0;
}
# 1111 "include/net/sock.h"
static inline __attribute__((always_inline)) void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
{
 sock_hold(sk);
 skb->sk = sk;
 skb->destructor = sock_wfree;
 atomic_add(skb->truesize, &sk->sk_wmem_alloc);
}

static inline __attribute__((always_inline)) void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
 skb->sk = sk;
 skb->destructor = sock_rfree;
 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
}

extern void sk_reset_timer(struct sock *sk, struct timer_list* timer,
      unsigned long expires);

extern void sk_stop_timer(struct sock *sk, struct timer_list* timer);

extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);

static inline __attribute__((always_inline)) int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
{



 if (((&sk->sk_rmem_alloc)->counter) + skb->truesize >=
     (unsigned)sk->sk_rcvbuf)
  return -12;
 skb_set_owner_r(skb, sk);
 skb_queue_tail(&sk->sk_error_queue, skb);
 if (!sock_flag(sk, SOCK_DEAD))
  sk->sk_data_ready(sk, skb->len);
 return 0;
}





static inline __attribute__((always_inline)) int sock_error(struct sock *sk)
{
 int err;
 if (__builtin_expect(!!(!sk->sk_err), 1))
  return 0;
 err = ((__typeof__(*(&sk->sk_err)))__xchg((unsigned long)(0),(&sk->sk_err),sizeof(*(&sk->sk_err))));
 return -err;
}

static inline __attribute__((always_inline)) unsigned long sock_wspace(struct sock *sk)
{
 int amt = 0;

 if (!(sk->sk_shutdown & 2)) {
  amt = sk->sk_sndbuf - ((&sk->sk_wmem_alloc)->counter);
  if (amt < 0)
   amt = 0;
 }
 return amt;
}

static inline __attribute__((always_inline)) void sk_wake_async(struct sock *sk, int how, int band)
{
 if (sk->sk_socket && sk->sk_socket->fasync_list)
  sock_wake_async(sk->sk_socket, how, band);
}




static inline __attribute__((always_inline)) void sk_stream_moderate_sndbuf(struct sock *sk)
{
 if (!(sk->sk_userlocks & 1)) {
  sk->sk_sndbuf = ({ typeof(sk->sk_sndbuf) _x = (sk->sk_sndbuf); typeof(sk->sk_wmem_queued / 2) _y = (sk->sk_wmem_queued / 2); (void) (&_x == &_y); _x < _y ? _x : _y; });
  sk->sk_sndbuf = ({ typeof(sk->sk_sndbuf) _x = (sk->sk_sndbuf); typeof(2048) _y = (2048); (void) (&_x == &_y); _x > _y ? _x : _y; });
 }
}

static inline __attribute__((always_inline)) struct sk_buff *sk_stream_alloc_pskb(struct sock *sk,
         int size, int mem,
         gfp_t gfp)
{
 struct sk_buff *skb;
 int hdr_len;

 hdr_len = (((sk->__sk_common.skc_prot->max_header) + ((1 << 5) - 1)) & ~((1 << 5) - 1));
 skb = alloc_skb_fclone(size + hdr_len, gfp);
 if (skb) {
  skb->truesize += mem;
  if (sk_stream_wmem_schedule(sk, skb->truesize)) {
   skb_reserve(skb, hdr_len);
   return skb;
  }
  __kfree_skb(skb);
 } else {
  sk->__sk_common.skc_prot->enter_memory_pressure();
  sk_stream_moderate_sndbuf(sk);
 }
 return ((void *)0);
}

static inline __attribute__((always_inline)) struct sk_buff *sk_stream_alloc_skb(struct sock *sk,
        int size,
        gfp_t gfp)
{
 return sk_stream_alloc_pskb(sk, size, 0, gfp);
}

static inline __attribute__((always_inline)) struct page *sk_stream_alloc_page(struct sock *sk)
{
 struct page *page = ((void *)0);

 page = alloc_pages_node(((0)), sk->sk_allocation, 0);
 if (!page) {
  sk->__sk_common.skc_prot->enter_memory_pressure();
  sk_stream_moderate_sndbuf(sk);
 }
 return page;
}
# 1247 "include/net/sock.h"
static inline __attribute__((always_inline)) int sock_writeable(const struct sock *sk)
{
 return ((&sk->sk_wmem_alloc)->counter) < (sk->sk_sndbuf / 2);
}

static inline __attribute__((always_inline)) gfp_t gfp_any(void)
{
 return (((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8)))) ? ((( gfp_t)0x20u)) : ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u));
}

static inline __attribute__((always_inline)) long sock_rcvtimeo(const struct sock *sk, int noblock)
{
 return noblock ? 0 : sk->sk_rcvtimeo;
}

static inline __attribute__((always_inline)) long sock_sndtimeo(const struct sock *sk, int noblock)
{
 return noblock ? 0 : sk->sk_sndtimeo;
}

static inline __attribute__((always_inline)) int sock_rcvlowat(const struct sock *sk, int waitall, int len)
{
 return (waitall ? len : ({ int __x = (sk->sk_rcvlowat); int __y = (len); __x < __y ? __x: __y; })) ? : 1;
}




static inline __attribute__((always_inline)) int sock_intr_errno(long timeo)
{
 return timeo == ((long)(~0UL>>1)) ? -512 : -4;
}

static __inline__ __attribute__((always_inline)) void
sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
{
 struct timeval stamp;

 skb_get_timestamp(skb, &stamp);
 if (sock_flag(sk, SOCK_RCVTSTAMP)) {


  if (stamp.tv_sec == 0)
   do_gettimeofday(&stamp);
  skb_set_timestamp(skb, &stamp);
  put_cmsg(msg, 1, 29, sizeof(struct timeval),
    &stamp);
 } else
  sk->sk_stamp = stamp;
}
# 1317 "include/net/sock.h"
static inline __attribute__((always_inline)) void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
{
 __skb_unlink(skb, &sk->sk_receive_queue);
 __kfree_skb(skb);
}


extern void sock_enable_timestamp(struct sock *sk);
extern int sock_get_timestamp(struct sock *, struct timeval *);
# 1363 "include/net/sock.h"
static inline __attribute__((always_inline)) void sock_valbool_flag(struct sock *sk, int bit, int valbool)
{
 if (valbool)
  sock_set_flag(sk, bit);
 else
  sock_reset_flag(sk, bit);
}

extern __u32 sysctl_wmem_max;
extern __u32 sysctl_rmem_max;


int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);







extern void sk_init(void);


extern struct ctl_table core_table[];


extern int sysctl_optmem_max;

extern __u32 sysctl_wmem_default;
extern __u32 sysctl_rmem_default;
# 25 "include/net/inet_sock.h" 2
# 1 "include/net/request_sock.h" 1
# 24 "include/net/request_sock.h"
struct request_sock;
struct sk_buff;
struct dst_entry;
struct proto;

struct request_sock_ops {
 int family;
 kmem_cache_t *slab;
 int obj_size;
 int (*rtx_syn_ack)(struct sock *sk,
           struct request_sock *req,
           struct dst_entry *dst);
 void (*send_ack)(struct sk_buff *skb,
        struct request_sock *req);
 void (*send_reset)(struct sk_buff *skb);
 void (*destructor)(struct request_sock *req);
};



struct request_sock {
 struct request_sock *dl_next;
 u16 mss;
 u8 retrans;
 u8 __pad;

 u32 window_clamp;
 u32 rcv_wnd;
 u32 ts_recent;
 unsigned long expires;
 struct request_sock_ops *rsk_ops;
 struct sock *sk;
 u32 secid;
};

static inline __attribute__((always_inline)) struct request_sock *reqsk_alloc(struct request_sock_ops *ops)
{
 struct request_sock *req = kmem_cache_alloc(ops->slab, ((( gfp_t)0x20u)));

 if (req != ((void *)0))
  req->rsk_ops = ops;

 return req;
}

static inline __attribute__((always_inline)) void __reqsk_free(struct request_sock *req)
{
 kmem_cache_free(req->rsk_ops->slab, req);
}

static inline __attribute__((always_inline)) void reqsk_free(struct request_sock *req)
{
 req->rsk_ops->destructor(req);
 __reqsk_free(req);
}

extern int sysctl_max_syn_backlog;





struct listen_sock {
 u8 max_qlen_log;

 int qlen;
 int qlen_young;
 int clock_hand;
 u32 hash_rnd;
 u32 nr_table_entries;
 struct request_sock *syn_table[0];
};
# 113 "include/net/request_sock.h"
struct request_sock_queue {
 struct request_sock *rskq_accept_head;
 struct request_sock *rskq_accept_tail;
 rwlock_t syn_wait_lock;
 u8 rskq_defer_accept;

 struct listen_sock *listen_opt;
};

extern int reqsk_queue_alloc(struct request_sock_queue *queue,
        const int nr_table_entries);

static inline __attribute__((always_inline)) struct listen_sock *reqsk_queue_yank_listen_sk(struct request_sock_queue *queue)
{
 struct listen_sock *lopt;

 do { local_bh_disable(); do { do { } while (0); (void)0; (void)(&queue->syn_wait_lock); } while (0); } while (0);
 lopt = queue->listen_opt;
 queue->listen_opt = ((void *)0);
 do { do { } while (0); local_bh_enable(); (void)0; (void)(&queue->syn_wait_lock); } while (0);

 return lopt;
}

static inline __attribute__((always_inline)) void __reqsk_queue_destroy(struct request_sock_queue *queue)
{
 kfree(reqsk_queue_yank_listen_sk(queue));
}

extern void reqsk_queue_destroy(struct request_sock_queue *queue);

static inline __attribute__((always_inline)) struct request_sock *
 reqsk_queue_yank_acceptq(struct request_sock_queue *queue)
{
 struct request_sock *req = queue->rskq_accept_head;

 queue->rskq_accept_head = ((void *)0);
 return req;
}

static inline __attribute__((always_inline)) int reqsk_queue_empty(struct request_sock_queue *queue)
{
 return queue->rskq_accept_head == ((void *)0);
}

static inline __attribute__((always_inline)) void reqsk_queue_unlink(struct request_sock_queue *queue,
          struct request_sock *req,
          struct request_sock **prev_req)
{
 do { do { } while (0); (void)0; (void)(&queue->syn_wait_lock); } while (0);
 *prev_req = req->dl_next;
 do { do { } while (0); (void)0; (void)(&queue->syn_wait_lock); } while (0);
}

static inline __attribute__((always_inline)) void reqsk_queue_add(struct request_sock_queue *queue,
       struct request_sock *req,
       struct sock *parent,
       struct sock *child)
{
 req->sk = child;
 sk_acceptq_added(parent);

 if (queue->rskq_accept_head == ((void *)0))
  queue->rskq_accept_head = req;
 else
  queue->rskq_accept_tail->dl_next = req;

 queue->rskq_accept_tail = req;
 req->dl_next = ((void *)0);
}

static inline __attribute__((always_inline)) struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
{
 struct request_sock *req = queue->rskq_accept_head;

 do { if (__builtin_expect(!!(!(req != ((void *)0))), 0)) { printk("<3>" "KERNEL: assertion (%s) failed at %s (%d)\n", "req != NULL", "include/net/request_sock.h" , 188); } } while(0);

 queue->rskq_accept_head = req->dl_next;
 if (queue->rskq_accept_head == ((void *)0))
  queue->rskq_accept_tail = ((void *)0);

 return req;
}

static inline __attribute__((always_inline)) struct sock *reqsk_queue_get_child(struct request_sock_queue *queue,
       struct sock *parent)
{
 struct request_sock *req = reqsk_queue_remove(queue);
 struct sock *child = req->sk;

 do { if (__builtin_expect(!!(!(child != ((void *)0))), 0)) { printk("<3>" "KERNEL: assertion (%s) failed at %s (%d)\n", "child != NULL", "include/net/request_sock.h" , 203); } } while(0);

 sk_acceptq_removed(parent);
 __reqsk_free(req);
 return child;
}

static inline __attribute__((always_inline)) int reqsk_queue_removed(struct request_sock_queue *queue,
          struct request_sock *req)
{
 struct listen_sock *lopt = queue->listen_opt;

 if (req->retrans == 0)
  --lopt->qlen_young;

 return --lopt->qlen;
}

static inline __attribute__((always_inline)) int reqsk_queue_added(struct request_sock_queue *queue)
{
 struct listen_sock *lopt = queue->listen_opt;
 const int prev_qlen = lopt->qlen;

 lopt->qlen_young++;
 lopt->qlen++;
 return prev_qlen;
}

static inline __attribute__((always_inline)) int reqsk_queue_len(const struct request_sock_queue *queue)
{
 return queue->listen_opt != ((void *)0) ? queue->listen_opt->qlen : 0;
}

static inline __attribute__((always_inline)) int reqsk_queue_len_young(const struct request_sock_queue *queue)
{
 return queue->listen_opt->qlen_young;
}

static inline __attribute__((always_inline)) int reqsk_queue_is_full(const struct request_sock_queue *queue)
{
 return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;
}

static inline __attribute__((always_inline)) void reqsk_queue_hash_req(struct request_sock_queue *queue,
     u32 hash, struct request_sock *req,
     unsigned long timeout)
{
 struct listen_sock *lopt = queue->listen_opt;

 req->expires = jiffies + timeout;
 req->retrans = 0;
 req->sk = ((void *)0);
 req->dl_next = lopt->syn_table[hash];

 do { do { } while (0); (void)0; (void)(&queue->syn_wait_lock); } while (0);
 lopt->syn_table[hash] = req;
 do { do { } while (0); (void)0; (void)(&queue->syn_wait_lock); } while (0);
}
# 26 "include/net/inet_sock.h" 2
# 38 "include/net/inet_sock.h"
struct ip_options {
 __be32 faddr;
 unsigned char optlen;
 unsigned char srr;
 unsigned char rr;
 unsigned char ts;
 unsigned char is_data:1,
   is_strictroute:1,
   srr_is_hit:1,
   is_changed:1,
   rr_needaddr:1,
   ts_needtime:1,
   ts_needaddr:1;
 unsigned char router_alert;
 unsigned char cipso;
 unsigned char __pad2;
 unsigned char __data[0];
};



struct inet_request_sock {
 struct request_sock req;




 __be32 loc_addr;
 __be32 rmt_addr;
 __be16 rmt_port;
 u16 snd_wscale : 4,
    rcv_wscale : 4,
    tstamp_ok : 1,
    sack_ok : 1,
    wscale_ok : 1,
    ecn_ok : 1,
    acked : 1;
 struct ip_options *opt;
};

static inline __attribute__((always_inline)) struct inet_request_sock *inet_rsk(const struct request_sock *sk)
{
 return (struct inet_request_sock *)sk;
}

struct ip_mc_socklist;
struct ipv6_pinfo;
struct rtable;
# 106 "include/net/inet_sock.h"
struct inet_sock {

 struct sock sk;




 __be32 daddr;
 __be32 rcv_saddr;
 __be16 dport;
 __u16 num;
 __be32 saddr;
 __s16 uc_ttl;
 __u16 cmsg_flags;
 struct ip_options *opt;
 __be16 sport;
 __u16 id;
 __u8 tos;
 __u8 mc_ttl;
 __u8 pmtudisc;
 __u8 recverr:1,
    is_icsk:1,
    freebind:1,
    hdrincl:1,
    mc_loop:1;
 int mc_index;
 __be32 mc_addr;
 struct ip_mc_socklist *mc_list;
 struct {
  unsigned int flags;
  unsigned int fragsize;
  struct ip_options *opt;
  struct rtable *rt;
  int length;
  __be32 addr;
  struct flowi fl;
 } cork;
};




static inline __attribute__((always_inline)) struct inet_sock *inet_sk(const struct sock *sk)
{
 return (struct inet_sock *)sk;
}

static inline __attribute__((always_inline)) void __inet_sk_copy_descendant(struct sock *sk_to,
          const struct sock *sk_from,
          const int ancestor_size)
{
 memcpy(inet_sk(sk_to) + 1, inet_sk(sk_from) + 1,
        sk_from->__sk_common.skc_prot->obj_size - ancestor_size);
}

static inline __attribute__((always_inline)) void inet_sk_copy_descendant(struct sock *sk_to,
        const struct sock *sk_from)
{
 __inet_sk_copy_descendant(sk_to, sk_from, sizeof(struct inet_sock));
}


extern int inet_sk_rebuild_header(struct sock *sk);

static inline __attribute__((always_inline)) unsigned int inet_ehashfn(const __be32 laddr, const __u16 lport,
     const __be32 faddr, const __be16 fport)
{
 unsigned int h = (( __u32)laddr ^ lport) ^ (( __u32)faddr ^ ( __u32)fport);
 h ^= h >> 16;
 h ^= h >> 8;
 return h;
}

static inline __attribute__((always_inline)) int inet_sk_ehashfn(const struct sock *sk)
{
 const struct inet_sock *inet = inet_sk(sk);
 const __be32 laddr = inet->rcv_saddr;
 const __u16 lport = inet->num;
 const __be32 faddr = inet->daddr;
 const __be16 fport = inet->dport;

 return inet_ehashfn(laddr, lport, faddr, fport);
}
# 30 "include/net/ip.h" 2


struct sock;

struct inet_skb_parm
{
 struct ip_options opt;
 unsigned char flags;






};

struct ipcm_cookie
{
 __be32 addr;
 int oif;
 struct ip_options *opt;
};



struct ip_ra_chain
{
 struct ip_ra_chain *next;
 struct sock *sk;
 void (*destructor)(struct sock *);
};

extern struct ip_ra_chain *ip_ra_chain;
extern rwlock_t ip_ra_lock;
# 73 "include/net/ip.h"
struct msghdr;
struct net_device;
struct packet_type;
struct rtable;
struct sk_buff;
struct sockaddr;

extern void ip_mc_dropsocket(struct sock *);
extern void ip_mc_dropdevice(struct net_device *dev);
extern int igmp_mc_proc_init(void);





extern int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
           __be32 saddr, __be32 daddr,
           struct ip_options *opt);
extern int ip_rcv(struct sk_buff *skb, struct net_device *dev,
          struct packet_type *pt, struct net_device *orig_dev);
extern int ip_local_deliver(struct sk_buff *skb);
extern int ip_mr_input(struct sk_buff *skb);
extern int ip_output(struct sk_buff *skb);
extern int ip_mc_output(struct sk_buff *skb);
extern int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *));
extern int ip_do_nat(struct sk_buff *skb);
extern void ip_send_check(struct iphdr *ip);
extern int ip_queue_xmit(struct sk_buff *skb, int ipfragok);
extern void ip_init(void);
extern int ip_append_data(struct sock *sk,
           int getfrag(void *from, char *to, int offset, int len,
         int odd, struct sk_buff *skb),
    void *from, int len, int protolen,
    struct ipcm_cookie *ipc,
    struct rtable *rt,
    unsigned int flags);
extern int ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb);
extern ssize_t ip_append_page(struct sock *sk, struct page *page,
    int offset, size_t size, int flags);
extern int ip_push_pending_frames(struct sock *sk);
extern void ip_flush_pending_frames(struct sock *sk);


extern int ip4_datagram_connect(struct sock *sk,
          struct sockaddr *uaddr, int addr_len);
# 126 "include/net/ip.h"
static inline __attribute__((always_inline)) void ip_tr_mc_map(u32 addr, char *buf)
{
 buf[0]=0xC0;
 buf[1]=0x00;
 buf[2]=0x00;
 buf[3]=0x04;
 buf[4]=0x00;
 buf[5]=0x00;
}

struct ip_reply_arg {
 struct kvec iov[1];
 u32 csum;
 int csumoffset;

};

void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg,
     unsigned int len);

struct ipv4_config
{
 int log_martians;
 int no_pmtu_disc;
};

extern struct ipv4_config ipv4_config;
extern __typeof__(struct ipstats_mib) *ip_statistics[2];



extern __typeof__(struct linux_mib) *net_statistics[2];






extern int sysctl_local_port_range[2];
extern int sysctl_ip_default_ttl;
extern int sysctl_ip_nonlocal_bind;


extern int sysctl_ipfrag_high_thresh;
extern int sysctl_ipfrag_low_thresh;
extern int sysctl_ipfrag_time;
extern int sysctl_ipfrag_secret_interval;
extern int sysctl_ipfrag_max_dist;


extern int inet_peer_threshold;
extern int inet_peer_minttl;
extern int inet_peer_maxttl;
extern int inet_peer_gc_mintime;
extern int inet_peer_gc_maxtime;


extern int sysctl_ip_dynaddr;

extern void ipfrag_init(void);






static inline __attribute__((always_inline))
int ip_decrease_ttl(struct iphdr *iph)
{
 u32 check = iph->check;
 check += htons(0x0100);
 iph->check = check + (check>=0xFFFF);
 return --iph->ttl;
}

static inline __attribute__((always_inline))
int ip_dont_fragment(struct sock *sk, struct dst_entry *dst)
{
 return (inet_sk(sk)->pmtudisc == 2 ||
  (inet_sk(sk)->pmtudisc == 1 &&
   !(dst_metric(dst, RTAX_LOCK)&(1<<RTAX_MTU))));
}

extern void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more);

static inline __attribute__((always_inline)) void ip_select_ident(struct iphdr *iph, struct dst_entry *dst, struct sock *sk)
{
 if (iph->frag_off & htons(0x4000)) {





  iph->id = (sk && inet_sk(sk)->daddr) ?
     htons(inet_sk(sk)->id++) : 0;
 } else
  __ip_select_ident(iph, dst, 0);
}

static inline __attribute__((always_inline)) void ip_select_ident_more(struct iphdr *iph, struct dst_entry *dst, struct sock *sk, int more)
{
 if (iph->frag_off & htons(0x4000)) {
  if (sk && inet_sk(sk)->daddr) {
   iph->id = htons(inet_sk(sk)->id);
   inet_sk(sk)->id += 1 + more;
  } else
   iph->id = 0;
 } else
  __ip_select_ident(iph, dst, more);
}





static inline __attribute__((always_inline)) void ip_eth_mc_map(u32 addr, char *buf)
{
 addr=ntohl(addr);
 buf[0]=0x01;
 buf[1]=0x00;
 buf[2]=0x5e;
 buf[5]=addr&0xFF;
 addr>>=8;
 buf[4]=addr&0xFF;
 addr>>=8;
 buf[3]=addr&0x7F;
}






static inline __attribute__((always_inline)) void ip_ib_mc_map(u32 addr, char *buf)
{
 buf[0] = 0;
 buf[1] = 0xff;
 buf[2] = 0xff;
 buf[3] = 0xff;
 addr = ntohl(addr);
 buf[4] = 0xff;
 buf[5] = 0x12;
 buf[6] = 0x40;
 buf[7] = 0x1b;
 buf[8] = 0;
 buf[9] = 0;
 buf[10] = 0;
 buf[11] = 0;
 buf[12] = 0;
 buf[13] = 0;
 buf[14] = 0;
 buf[15] = 0;
 buf[19] = addr & 0xff;
 addr >>= 8;
 buf[18] = addr & 0xff;
 addr >>= 8;
 buf[17] = addr & 0xff;
 addr >>= 8;
 buf[16] = addr & 0x0f;
}





static __inline__ __attribute__((always_inline)) void inet_reset_saddr(struct sock *sk)
{
 inet_sk(sk)->rcv_saddr = inet_sk(sk)->saddr = 0;
# 302 "include/net/ip.h"
}



extern int ip_call_ra_chain(struct sk_buff *skb);





enum ip_defrag_users
{
 IP_DEFRAG_LOCAL_DELIVER,
 IP_DEFRAG_CALL_RA_CHAIN,
 IP_DEFRAG_CONNTRACK_IN,
 IP_DEFRAG_CONNTRACK_OUT,
 IP_DEFRAG_VS_IN,
 IP_DEFRAG_VS_OUT,
 IP_DEFRAG_VS_FWD
};

struct sk_buff *ip_defrag(struct sk_buff *skb, u32 user);
extern int ip_frag_nqueues;
extern atomic_t ip_frag_mem;





extern int ip_forward(struct sk_buff *skb);
extern int ip_net_unreachable(struct sk_buff *skb);





extern void ip_options_build(struct sk_buff *skb, struct ip_options *opt, __be32 daddr, struct rtable *rt, int is_frag);
extern int ip_options_echo(struct ip_options *dopt, struct sk_buff *skb);
extern void ip_options_fragment(struct sk_buff *skb);
extern int ip_options_compile(struct ip_options *opt, struct sk_buff *skb);
extern int ip_options_get(struct ip_options **optp,
     unsigned char *data, int optlen);
extern int ip_options_get_from_user(struct ip_options **optp,
        unsigned char *data, int optlen);
extern void ip_options_undo(struct ip_options * opt);
extern void ip_forward_options(struct sk_buff *skb);
extern int ip_options_rcv_srr(struct sk_buff *skb);





extern void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb);
extern int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc);
extern int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen);
extern int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
extern int compat_ip_setsockopt(struct sock *sk, int level,
   int optname, char *optval, int optlen);
extern int compat_ip_getsockopt(struct sock *sk, int level,
   int optname, char *optval, int *optlen);
extern int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *));

extern int ip_recv_error(struct sock *sk, struct msghdr *msg, int len);
extern void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
         __be16 port, u32 info, u8 *payload);
extern void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 dport,
          u32 info);




int ipv4_doint_and_flush(ctl_table *ctl, int write,
    struct file* filp, void *buffer,
    size_t *lenp, loff_t *ppos);
int ipv4_doint_and_flush_strategy(ctl_table *table, int *name, int nlen,
      void *oldval, size_t *oldlenp,
      void *newval, size_t newlen,
      void **context);

extern int ip_misc_proc_init(void);


extern struct ctl_table ipv4_table[];
# 69 "net/ipv4/ip_output.c" 2
# 1 "include/net/protocol.h" 1
# 36 "include/net/protocol.h"
struct net_protocol {
 int (*handler)(struct sk_buff *skb);
 void (*err_handler)(struct sk_buff *skb, u32 info);
 int (*gso_send_check)(struct sk_buff *skb);
 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
            int features);
 int no_policy;
};
# 69 "include/net/protocol.h"
struct inet_protosw {
 struct list_head list;


 unsigned short type;
 int protocol;

 struct proto *prot;
 const struct proto_ops *ops;

 int capability;



 char no_check;
 unsigned char flags;
};




extern struct net_protocol *inet_protocol_base;
extern struct net_protocol *inet_protos[256];





extern int inet_add_protocol(struct net_protocol *prot, unsigned char num);
extern int inet_del_protocol(struct net_protocol *prot, unsigned char num);
extern void inet_register_protosw(struct inet_protosw *p);
extern void inet_unregister_protosw(struct inet_protosw *p);
# 70 "net/ipv4/ip_output.c" 2
# 1 "include/net/route.h" 1
# 28 "include/net/route.h"
# 1 "include/net/inetpeer.h" 1
# 18 "include/net/inetpeer.h"
struct inet_peer
{

 struct inet_peer *avl_left, *avl_right;
 __be32 v4daddr;
 __u16 avl_height;
 __u16 ip_id_count;
 struct inet_peer *unused_next, **unused_prevp;
 __u32 dtime;

 atomic_t refcnt;
 atomic_t rid;
 __u32 tcp_ts;
 unsigned long tcp_ts_stamp;
};

void inet_initpeers(void) __attribute__ ((__section__ (".init.text")));


struct inet_peer *inet_getpeer(__be32 daddr, int create);


extern void inet_putpeer(struct inet_peer *p);

extern spinlock_t inet_peer_idlock;

static inline __attribute__((always_inline)) __u16 inet_getid(struct inet_peer *p, int more)
{
 __u16 id;

 do { local_bh_disable(); do { do { } while (0); (void)0; (void)(&inet_peer_idlock); } while (0); } while (0);
 id = p->ip_id_count;
 p->ip_id_count += 1 + more;
 do { do { } while (0); local_bh_enable(); (void)0; (void)(&inet_peer_idlock); } while (0);
 return id;
}
# 29 "include/net/route.h" 2

# 1 "include/linux/in_route.h" 1
# 31 "include/net/route.h" 2

# 1 "include/linux/route.h" 1
# 30 "include/linux/route.h"
struct rtentry
{
 unsigned long rt_pad1;
 struct sockaddr rt_dst;
 struct sockaddr rt_gateway;
 struct sockaddr rt_genmask;
 unsigned short rt_flags;
 short rt_pad2;
 unsigned long rt_pad3;
 void *rt_pad4;
 short rt_metric;
 char *rt_dev;
 unsigned long rt_mtu;



 unsigned long rt_window;
 unsigned short rt_irtt;
};
# 33 "include/net/route.h" 2
# 49 "include/net/route.h"
struct fib_nh;
struct inet_peer;
struct rtable
{
 union
 {
  struct dst_entry dst;
  struct rtable *rt_next;
 } u;

 struct in_device *idev;

 unsigned rt_flags;
 __u16 rt_type;
 __u16 rt_multipath_alg;

 __be32 rt_dst;
 __be32 rt_src;
 int rt_iif;


 __be32 rt_gateway;


 struct flowi fl;


 __be32 rt_spec_dst;
 struct inet_peer *peer;
};

struct ip_rt_acct
{
 __u32 o_bytes;
 __u32 o_packets;
 __u32 i_bytes;
 __u32 i_packets;
};

struct rt_cache_stat
{
        unsigned int in_hit;
        unsigned int in_slow_tot;
        unsigned int in_slow_mc;
        unsigned int in_no_route;
        unsigned int in_brd;
        unsigned int in_martian_dst;
        unsigned int in_martian_src;
        unsigned int out_hit;
        unsigned int out_slow_tot;
        unsigned int out_slow_mc;
        unsigned int gc_total;
        unsigned int gc_ignored;
        unsigned int gc_goal_miss;
        unsigned int gc_dst_overflow;
        unsigned int in_hlist_search;
        unsigned int out_hlist_search;
};

extern struct ip_rt_acct *ip_rt_acct;

struct in_device;
extern int ip_rt_init(void);
extern void ip_rt_redirect(__be32 old_gw, __be32 dst, __be32 new_gw,
           __be32 src, struct net_device *dev);
extern void ip_rt_advice(struct rtable **rp, int advice);
extern void rt_cache_flush(int how);
extern int __ip_route_output_key(struct rtable **, const struct flowi *flp);
extern int ip_route_output_key(struct rtable **, struct flowi *flp);
extern int ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
extern int ip_route_input(struct sk_buff*, __be32 dst, __be32 src, u8 tos, struct net_device *devin);
extern unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
extern void ip_rt_send_redirect(struct sk_buff *skb);

extern unsigned inet_addr_type(__be32 addr);
extern void ip_rt_multicast_event(struct in_device *);
extern int ip_rt_ioctl(unsigned int cmd, void *arg);
extern void ip_rt_get_source(u8 *src, struct rtable *rt);
extern int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb);

struct in_ifaddr;
extern void fib_add_ifaddr(struct in_ifaddr *);

static inline __attribute__((always_inline)) void ip_rt_put(struct rtable * rt)
{
 if (rt)
  dst_release(&rt->u.dst);
}



extern __u8 ip_tos2prio[16];

static inline __attribute__((always_inline)) char rt_tos2priority(u8 tos)
{
 return ip_tos2prio[((tos)&0x1E)>>1];
}

static inline __attribute__((always_inline)) int ip_route_connect(struct rtable **rp, __be32 dst,
       __be32 src, u32 tos, int oif, u8 protocol,
       __be16 sport, __be16 dport, struct sock *sk)
{
 struct flowi fl = { .oif = oif,
       .nl_u = { .ip4_u = { .daddr = dst,
       .saddr = src,
       .tos = tos } },
       .proto = protocol,
       .uli_u = { .ports =
           { .sport = sport,
      .dport = dport } } };

 int err;
 if (!dst || !src) {
  err = __ip_route_output_key(rp, &fl);
  if (err)
   return err;
  fl.nl_u.ip4_u.daddr = (*rp)->rt_dst;
  fl.nl_u.ip4_u.saddr = (*rp)->rt_src;
  ip_rt_put(*rp);
  *rp = ((void *)0);
 }
 security_sk_classify_flow(sk, &fl);
 return ip_route_output_flow(rp, &fl, sk, 0);
}

static inline __attribute__((always_inline)) int ip_route_newports(struct rtable **rp, u8 protocol,
        __be16 sport, __be16 dport, struct sock *sk)
{
 if (sport != (*rp)->fl.uli_u.ports.sport ||
     dport != (*rp)->fl.uli_u.ports.dport) {
  struct flowi fl;

  memcpy(&fl, &(*rp)->fl, sizeof(fl));
  fl.uli_u.ports.sport = sport;
  fl.uli_u.ports.dport = dport;
  fl.proto = protocol;
  ip_rt_put(*rp);
  *rp = ((void *)0);
  security_sk_classify_flow(sk, &fl);
  return ip_route_output_flow(rp, &fl, sk, 0);
 }
 return 0;
}

extern void rt_bind_peer(struct rtable *rt, int create);

static inline __attribute__((always_inline)) struct inet_peer *rt_get_peer(struct rtable *rt)
{
 if (rt->peer)
  return rt->peer;

 rt_bind_peer(rt, 0);
 return rt->peer;
}

extern ctl_table ipv4_route_table[];
# 71 "net/ipv4/ip_output.c" 2
# 1 "include/net/xfrm.h" 1
# 11 "include/net/xfrm.h"
# 1 "include/linux/pfkeyv2.h" 1
# 14 "include/linux/pfkeyv2.h"
struct sadb_msg {
 uint8_t sadb_msg_version;
 uint8_t sadb_msg_type;
 uint8_t sadb_msg_errno;
 uint8_t sadb_msg_satype;
 uint16_t sadb_msg_len;
 uint16_t sadb_msg_reserved;
 uint32_t sadb_msg_seq;
 uint32_t sadb_msg_pid;
} __attribute__((packed));


struct sadb_ext {
 uint16_t sadb_ext_len;
 uint16_t sadb_ext_type;
} __attribute__((packed));


struct sadb_sa {
 uint16_t sadb_sa_len;
 uint16_t sadb_sa_exttype;
 uint32_t sadb_sa_spi;
 uint8_t sadb_sa_replay;
 uint8_t sadb_sa_state;
 uint8_t sadb_sa_auth;
 uint8_t sadb_sa_encrypt;
 uint32_t sadb_sa_flags;
} __attribute__((packed));


struct sadb_lifetime {
 uint16_t sadb_lifetime_len;
 uint16_t sadb_lifetime_exttype;
 uint32_t sadb_lifetime_allocations;
 uint64_t sadb_lifetime_bytes;
 uint64_t sadb_lifetime_addtime;
 uint64_t sadb_lifetime_usetime;
} __attribute__((packed));


struct sadb_address {
 uint16_t sadb_address_len;
 uint16_t sadb_address_exttype;
 uint8_t sadb_address_proto;
 uint8_t sadb_address_prefixlen;
 uint16_t sadb_address_reserved;
} __attribute__((packed));


struct sadb_key {
 uint16_t sadb_key_len;
 uint16_t sadb_key_exttype;
 uint16_t sadb_key_bits;
 uint16_t sadb_key_reserved;
} __attribute__((packed));


struct sadb_ident {
 uint16_t sadb_ident_len;
 uint16_t sadb_ident_exttype;
 uint16_t sadb_ident_type;
 uint16_t sadb_ident_reserved;
 uint64_t sadb_ident_id;
} __attribute__((packed));


struct sadb_sens {
 uint16_t sadb_sens_len;
 uint16_t sadb_sens_exttype;
 uint32_t sadb_sens_dpd;
 uint8_t sadb_sens_sens_level;
 uint8_t sadb_sens_sens_len;
 uint8_t sadb_sens_integ_level;
 uint8_t sadb_sens_integ_len;
 uint32_t sadb_sens_reserved;
} __attribute__((packed));






struct sadb_prop {
 uint16_t sadb_prop_len;
 uint16_t sadb_prop_exttype;
 uint8_t sadb_prop_replay;
 uint8_t sadb_prop_reserved[3];
} __attribute__((packed));







struct sadb_comb {
 uint8_t sadb_comb_auth;
 uint8_t sadb_comb_encrypt;
 uint16_t sadb_comb_flags;
 uint16_t sadb_comb_auth_minbits;
 uint16_t sadb_comb_auth_maxbits;
 uint16_t sadb_comb_encrypt_minbits;
 uint16_t sadb_comb_encrypt_maxbits;
 uint32_t sadb_comb_reserved;
 uint32_t sadb_comb_soft_allocations;
 uint32_t sadb_comb_hard_allocations;
 uint64_t sadb_comb_soft_bytes;
 uint64_t sadb_comb_hard_bytes;
 uint64_t sadb_comb_soft_addtime;
 uint64_t sadb_comb_hard_addtime;
 uint64_t sadb_comb_soft_usetime;
 uint64_t sadb_comb_hard_usetime;
} __attribute__((packed));


struct sadb_supported {
 uint16_t sadb_supported_len;
 uint16_t sadb_supported_exttype;
 uint32_t sadb_supported_reserved;
} __attribute__((packed));







struct sadb_alg {
 uint8_t sadb_alg_id;
 uint8_t sadb_alg_ivlen;
 uint16_t sadb_alg_minbits;
 uint16_t sadb_alg_maxbits;
 uint16_t sadb_alg_reserved;
} __attribute__((packed));


struct sadb_spirange {
 uint16_t sadb_spirange_len;
 uint16_t sadb_spirange_exttype;
 uint32_t sadb_spirange_min;
 uint32_t sadb_spirange_max;
 uint32_t sadb_spirange_reserved;
} __attribute__((packed));


struct sadb_x_kmprivate {
 uint16_t sadb_x_kmprivate_len;
 uint16_t sadb_x_kmprivate_exttype;
 uint32_t sadb_x_kmprivate_reserved;
} __attribute__((packed));


struct sadb_x_sa2 {
 uint16_t sadb_x_sa2_len;
 uint16_t sadb_x_sa2_exttype;
 uint8_t sadb_x_sa2_mode;
 uint8_t sadb_x_sa2_reserved1;
 uint16_t sadb_x_sa2_reserved2;
 uint32_t sadb_x_sa2_sequence;
 uint32_t sadb_x_sa2_reqid;
} __attribute__((packed));


struct sadb_x_policy {
 uint16_t sadb_x_policy_len;
 uint16_t sadb_x_policy_exttype;
 uint16_t sadb_x_policy_type;
 uint8_t sadb_x_policy_dir;
 uint8_t sadb_x_policy_reserved;
 uint32_t sadb_x_policy_id;
 uint32_t sadb_x_policy_priority;
} __attribute__((packed));


struct sadb_x_ipsecrequest {
 uint16_t sadb_x_ipsecrequest_len;
 uint16_t sadb_x_ipsecrequest_proto;
 uint8_t sadb_x_ipsecrequest_mode;
 uint8_t sadb_x_ipsecrequest_level;
 uint16_t sadb_x_ipsecrequest_reserved1;
 uint32_t sadb_x_ipsecrequest_reqid;
 uint32_t sadb_x_ipsecrequest_reserved2;
} __attribute__((packed));





struct sadb_x_nat_t_type {
 uint16_t sadb_x_nat_t_type_len;
 uint16_t sadb_x_nat_t_type_exttype;
 uint8_t sadb_x_nat_t_type_type;
 uint8_t sadb_x_nat_t_type_reserved[3];
} __attribute__((packed));



struct sadb_x_nat_t_port {
 uint16_t sadb_x_nat_t_port_len;
 uint16_t sadb_x_nat_t_port_exttype;
 uint16_t sadb_x_nat_t_port_port;
 uint16_t sadb_x_nat_t_port_reserved;
} __attribute__((packed));



struct sadb_x_sec_ctx {
 uint16_t sadb_x_sec_len;
 uint16_t sadb_x_sec_exttype;
 uint8_t sadb_x_ctx_alg;
 uint8_t sadb_x_ctx_doi;
 uint16_t sadb_x_ctx_len;
} __attribute__((packed));
# 12 "include/net/xfrm.h" 2
# 1 "include/linux/ipsec.h" 1
# 12 "include/linux/ipsec.h"
enum {
 IPSEC_MODE_ANY = 0,
 IPSEC_MODE_TRANSPORT = 1,
 IPSEC_MODE_TUNNEL = 2,
 IPSEC_MODE_BEET = 3
};

enum {
 IPSEC_DIR_ANY = 0,
 IPSEC_DIR_INBOUND = 1,
 IPSEC_DIR_OUTBOUND = 2,
 IPSEC_DIR_FWD = 3,
 IPSEC_DIR_MAX = 4,
 IPSEC_DIR_INVALID = 5
};

enum {
 IPSEC_POLICY_DISCARD = 0,
 IPSEC_POLICY_NONE = 1,
 IPSEC_POLICY_IPSEC = 2,
 IPSEC_POLICY_ENTRUST = 3,
 IPSEC_POLICY_BYPASS = 4
};

enum {
 IPSEC_LEVEL_DEFAULT = 0,
 IPSEC_LEVEL_USE = 1,
 IPSEC_LEVEL_REQUIRE = 2,
 IPSEC_LEVEL_UNIQUE = 3
};
# 13 "include/net/xfrm.h" 2






# 1 "include/net/ipv6.h" 1
# 18 "include/net/ipv6.h"
# 1 "include/linux/ipv6.h" 1
# 18 "include/linux/ipv6.h"
struct in6_pktinfo {
 struct in6_addr ipi6_addr;
 int ipi6_ifindex;
};


struct in6_ifreq {
 struct in6_addr ifr6_addr;
 __u32 ifr6_prefixlen;
 int ifr6_ifindex;
};
# 37 "include/linux/ipv6.h"
struct ipv6_rt_hdr {
 __u8 nexthdr;
 __u8 hdrlen;
 __u8 type;
 __u8 segments_left;





};


struct ipv6_opt_hdr {
 __u8 nexthdr;
 __u8 hdrlen;



};
# 69 "include/linux/ipv6.h"
struct rt0_hdr {
 struct ipv6_rt_hdr rt_hdr;
 __u32 reserved;
 struct in6_addr addr[0];


};





struct rt2_hdr {
 struct ipv6_rt_hdr rt_hdr;
 __u32 reserved;
 struct in6_addr addr;


};





struct ipv6_destopt_hao {
 __u8 type;
 __u8 length;
 struct in6_addr addr;
} __attribute__ ((__packed__));

struct ipv6_auth_hdr {
 __u8 nexthdr;
 __u8 hdrlen;
 __be16 reserved;
 __be32 spi;
 __be32 seq_no;
 __u8 auth_data[0];
};

struct ipv6_esp_hdr {
 __be32 spi;
 __be32 seq_no;
 __u8 enc_data[0];
};

struct ipv6_comp_hdr {
 __u8 nexthdr;
 __u8 flags;
 __be16 cpi;
};
# 127 "include/linux/ipv6.h"
struct ipv6hdr {

 __u8 priority:4,
    version:4;






 __u8 flow_lbl[3];

 __be16 payload_len;
 __u8 nexthdr;
 __u8 hop_limit;

 struct in6_addr saddr;
 struct in6_addr daddr;
};




struct ipv6_devconf {
 __s32 forwarding;
 __s32 hop_limit;
 __s32 mtu6;
 __s32 accept_ra;
 __s32 accept_redirects;
 __s32 autoconf;
 __s32 dad_transmits;
 __s32 rtr_solicits;
 __s32 rtr_solicit_interval;
 __s32 rtr_solicit_delay;
 __s32 force_mld_version;







 __s32 max_addresses;
 __s32 accept_ra_defrtr;
 __s32 accept_ra_pinfo;







 __s32 proxy_ndp;
 void *sysctl;
};


enum {
 DEVCONF_FORWARDING = 0,
 DEVCONF_HOPLIMIT,
 DEVCONF_MTU6,
 DEVCONF_ACCEPT_RA,
 DEVCONF_ACCEPT_REDIRECTS,
 DEVCONF_AUTOCONF,
 DEVCONF_DAD_TRANSMITS,
 DEVCONF_RTR_SOLICITS,
 DEVCONF_RTR_SOLICIT_INTERVAL,
 DEVCONF_RTR_SOLICIT_DELAY,
 DEVCONF_USE_TEMPADDR,
 DEVCONF_TEMP_VALID_LFT,
 DEVCONF_TEMP_PREFERED_LFT,
 DEVCONF_REGEN_MAX_RETRY,
 DEVCONF_MAX_DESYNC_FACTOR,
 DEVCONF_MAX_ADDRESSES,
 DEVCONF_FORCE_MLD_VERSION,
 DEVCONF_ACCEPT_RA_DEFRTR,
 DEVCONF_ACCEPT_RA_PINFO,
 DEVCONF_ACCEPT_RA_RTR_PREF,
 DEVCONF_RTR_PROBE_INTERVAL,
 DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN,
 DEVCONF_PROXY_NDP,
 DEVCONF_MAX
};


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





struct icmp6hdr {

 __u8 icmp6_type;
 __u8 icmp6_code;
 __u16 icmp6_cksum;


 union {
  __u32 un_data32[1];
  __u16 un_data16[2];
  __u8 un_data8[4];

  struct icmpv6_echo {
   __u16 identifier;
   __u16 sequence;
  } u_echo;

                struct icmpv6_nd_advt {

                        __u32 reserved:5,
                          override:1,
                          solicited:1,
                          router:1,
     reserved2:24;
# 38 "include/linux/icmpv6.h"
                } u_nd_advt;

                struct icmpv6_nd_ra {
   __u8 hop_limit;

   __u8 reserved:4,
     router_pref:2,
     other:1,
     managed:1;
# 56 "include/linux/icmpv6.h"
   __u16 rt_lifetime;
                } u_nd_ra;

 } icmp6_dataun;
# 76 "include/linux/icmpv6.h"
};
# 143 "include/linux/icmpv6.h"
struct icmp6_filter {
 __u32 data[8];
};
# 165 "include/linux/icmpv6.h"
extern void icmpv6_send(struct sk_buff *skb,
          int type, int code,
          __u32 info,
          struct net_device *dev);

extern int icmpv6_init(struct net_proto_family *ops);
extern int icmpv6_err_convert(int type, int code,
          int *err);
extern void icmpv6_cleanup(void);
extern void icmpv6_param_prob(struct sk_buff *skb,
         int code, int pos);
# 213 "include/linux/ipv6.h" 2
# 1 "include/linux/tcp.h" 1
# 23 "include/linux/tcp.h"
struct tcphdr {
 __be16 source;
 __be16 dest;
 __be32 seq;
 __be32 ack_seq;

 __u16 res1:4,
  doff:4,
  fin:1,
  syn:1,
  rst:1,
  psh:1,
  ack:1,
  urg:1,
  ece:1,
  cwr:1;
# 53 "include/linux/tcp.h"
 __be16 window;
 __be16 check;
 __be16 urg_ptr;
};






union tcp_word_hdr {
 struct tcphdr hdr;
 __be32 words[5];
};



enum {
 TCP_FLAG_CWR = (( __be32)((__u32)( (((__u32)((0x00800000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00800000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00800000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00800000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_ECE = (( __be32)((__u32)( (((__u32)((0x00400000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00400000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00400000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00400000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_URG = (( __be32)((__u32)( (((__u32)((0x00200000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00200000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00200000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00200000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_ACK = (( __be32)((__u32)( (((__u32)((0x00100000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00100000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00100000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00100000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_PSH = (( __be32)((__u32)( (((__u32)((0x00080000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00080000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00080000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00080000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_RST = (( __be32)((__u32)( (((__u32)((0x00040000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00040000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00040000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00040000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_SYN = (( __be32)((__u32)( (((__u32)((0x00020000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00020000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00020000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00020000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_FLAG_FIN = (( __be32)((__u32)( (((__u32)((0x00010000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x00010000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x00010000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x00010000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_RESERVED_BITS = (( __be32)((__u32)( (((__u32)((0x0F000000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x0F000000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x0F000000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x0F000000)) & (__u32)0xff000000UL) >> 24) ))),
 TCP_DATA_OFFSET = (( __be32)((__u32)( (((__u32)((0xF0000000)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xF0000000)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xF0000000)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xF0000000)) & (__u32)0xff000000UL) >> 24) )))
};
# 103 "include/linux/tcp.h"
enum tcp_ca_state
{
 TCP_CA_Open = 0,

 TCP_CA_Disorder = 1,

 TCP_CA_CWR = 2,

 TCP_CA_Recovery = 3,

 TCP_CA_Loss = 4

};

struct tcp_info
{
 __u8 tcpi_state;
 __u8 tcpi_ca_state;
 __u8 tcpi_retransmits;
 __u8 tcpi_probes;
 __u8 tcpi_backoff;
 __u8 tcpi_options;
 __u8 tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;

 __u32 tcpi_rto;
 __u32 tcpi_ato;
 __u32 tcpi_snd_mss;
 __u32 tcpi_rcv_mss;

 __u32 tcpi_unacked;
 __u32 tcpi_sacked;
 __u32 tcpi_lost;
 __u32 tcpi_retrans;
 __u32 tcpi_fackets;


 __u32 tcpi_last_data_sent;
 __u32 tcpi_last_ack_sent;
 __u32 tcpi_last_data_recv;
 __u32 tcpi_last_ack_recv;


 __u32 tcpi_pmtu;
 __u32 tcpi_rcv_ssthresh;
 __u32 tcpi_rtt;
 __u32 tcpi_rttvar;
 __u32 tcpi_snd_ssthresh;
 __u32 tcpi_snd_cwnd;
 __u32 tcpi_advmss;
 __u32 tcpi_reordering;

 __u32 tcpi_rcv_rtt;
 __u32 tcpi_rcv_space;

 __u32 tcpi_total_retrans;
};






# 1 "include/net/inet_connection_sock.h" 1
# 30 "include/net/inet_connection_sock.h"
struct inet_bind_bucket;
struct inet_hashinfo;
struct tcp_congestion_ops;





struct inet_connection_sock_af_ops {
 int (*queue_xmit)(struct sk_buff *skb, int ipfragok);
 void (*send_check)(struct sock *sk, int len,
      struct sk_buff *skb);
 int (*rebuild_header)(struct sock *sk);
 int (*conn_request)(struct sock *sk, struct sk_buff *skb);
 struct sock *(*syn_recv_sock)(struct sock *sk, struct sk_buff *skb,
          struct request_sock *req,
          struct dst_entry *dst);
 int (*remember_stamp)(struct sock *sk);
 __u16 net_header_len;
 int (*setsockopt)(struct sock *sk, int level, int optname,
      char *optval, int optlen);
 int (*getsockopt)(struct sock *sk, int level, int optname,
      char *optval, int *optlen);
 int (*compat_setsockopt)(struct sock *sk,
    int level, int optname,
    char *optval, int optlen);
 int (*compat_getsockopt)(struct sock *sk,
    int level, int optname,
    char *optval, int *optlen);
 void (*addr2sockaddr)(struct sock *sk, struct sockaddr *);
 int sockaddr_len;
};
# 83 "include/net/inet_connection_sock.h"
struct inet_connection_sock {

 struct inet_sock icsk_inet;
 struct request_sock_queue icsk_accept_queue;
 struct inet_bind_bucket *icsk_bind_hash;
 unsigned long icsk_timeout;
  struct timer_list icsk_retransmit_timer;
  struct timer_list icsk_delack_timer;
 __u32 icsk_rto;
 __u32 icsk_pmtu_cookie;
 const struct tcp_congestion_ops *icsk_ca_ops;
 const struct inet_connection_sock_af_ops *icsk_af_ops;
 unsigned int (*icsk_sync_mss)(struct sock *sk, u32 pmtu);
 __u8 icsk_ca_state;
 __u8 icsk_retransmits;
 __u8 icsk_pending;
 __u8 icsk_backoff;
 __u8 icsk_syn_retries;
 __u8 icsk_probes_out;
 __u16 icsk_ext_hdr_len;
 struct {
  __u8 pending;
  __u8 quick;
  __u8 pingpong;
  __u8 blocked;
  __u32 ato;
  unsigned long timeout;
  __u32 lrcvtime;
  __u16 last_seg_size;
  __u16 rcv_mss;
 } icsk_ack;
 struct {
  int enabled;


  int search_high;
  int search_low;


  int probe_size;
 } icsk_mtup;
 u32 icsk_ca_priv[16];

};






static inline __attribute__((always_inline)) struct inet_connection_sock *inet_csk(const struct sock *sk)
{
 return (struct inet_connection_sock *)sk;
}

static inline __attribute__((always_inline)) void *inet_csk_ca(const struct sock *sk)
{
 return (void *)inet_csk(sk)->icsk_ca_priv;
}

extern struct sock *inet_csk_clone(struct sock *sk,
       const struct request_sock *req,
       const gfp_t priority);

enum inet_csk_ack_state_t {
 ICSK_ACK_SCHED = 1,
 ICSK_ACK_TIMER = 2,
 ICSK_ACK_PUSHED = 4,
 ICSK_ACK_PUSHED2 = 8
};

extern void inet_csk_init_xmit_timers(struct sock *sk,
          void (*retransmit_handler)(unsigned long),
          void (*delack_handler)(unsigned long),
          void (*keepalive_handler)(unsigned long));
extern void inet_csk_clear_xmit_timers(struct sock *sk);

static inline __attribute__((always_inline)) void inet_csk_schedule_ack(struct sock *sk)
{
 inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_SCHED;
}

static inline __attribute__((always_inline)) int inet_csk_ack_scheduled(const struct sock *sk)
{
 return inet_csk(sk)->icsk_ack.pending & ICSK_ACK_SCHED;
}

static inline __attribute__((always_inline)) void inet_csk_delack_init(struct sock *sk)
{
 memset(&inet_csk(sk)->icsk_ack, 0, sizeof(inet_csk(sk)->icsk_ack));
}

extern void inet_csk_delete_keepalive_timer(struct sock *sk);
extern void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long timeout);


extern const char inet_csk_timer_bug_msg[];


static inline __attribute__((always_inline)) void inet_csk_clear_xmit_timer(struct sock *sk, const int what)
{
 struct inet_connection_sock *icsk = inet_csk(sk);

 if (what == 1 || what == 3) {
  icsk->icsk_pending = 0;



 } else if (what == 2) {
  icsk->icsk_ack.blocked = icsk->icsk_ack.pending = 0;



 }

 else {
  pr_debug("%s", inet_csk_timer_bug_msg);
 }

}




static inline __attribute__((always_inline)) void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
          unsigned long when,
          const unsigned long max_when)
{
 struct inet_connection_sock *icsk = inet_csk(sk);

 if (when > max_when) {

  pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",
    sk, what, when, ({ __label__ _l; _l: &&_l;}));

  when = max_when;
 }

 if (what == 1 || what == 3) {
  icsk->icsk_pending = what;
  icsk->icsk_timeout = jiffies + when;
  sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
 } else if (what == 2) {
  icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
  icsk->icsk_ack.timeout = jiffies + when;
  sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
 }

 else {
  pr_debug("%s", inet_csk_timer_bug_msg);
 }

}

extern struct sock *inet_csk_accept(struct sock *sk, int flags, int *err);

extern struct request_sock *inet_csk_search_req(const struct sock *sk,
      struct request_sock ***prevp,
      const __be16 rport,
      const __be32 raddr,
      const __be32 laddr);
extern int inet_csk_bind_conflict(const struct sock *sk,
      const struct inet_bind_bucket *tb);
extern int inet_csk_get_port(struct inet_hashinfo *hashinfo,
        struct sock *sk, unsigned short snum,
        int (*bind_conflict)(const struct sock *sk,
        const struct inet_bind_bucket *tb));

extern struct dst_entry* inet_csk_route_req(struct sock *sk,
         const struct request_sock *req);

static inline __attribute__((always_inline)) void inet_csk_reqsk_queue_add(struct sock *sk,
         struct request_sock *req,
         struct sock *child)
{
 reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);
}

extern void inet_csk_reqsk_queue_hash_add(struct sock *sk,
       struct request_sock *req,
       unsigned long timeout);

static inline __attribute__((always_inline)) void inet_csk_reqsk_queue_removed(struct sock *sk,
      struct request_sock *req)
{
 if (reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req) == 0)
  inet_csk_delete_keepalive_timer(sk);
}

static inline __attribute__((always_inline)) void inet_csk_reqsk_queue_added(struct sock *sk,
           const unsigned long timeout)
{
 if (reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue) == 0)
  inet_csk_reset_keepalive_timer(sk, timeout);
}

static inline __attribute__((always_inline)) int inet_csk_reqsk_queue_len(const struct sock *sk)
{
 return reqsk_queue_len(&inet_csk(sk)->icsk_accept_queue);
}

static inline __attribute__((always_inline)) int inet_csk_reqsk_queue_young(const struct sock *sk)
{
 return reqsk_queue_len_young(&inet_csk(sk)->icsk_accept_queue);
}

static inline __attribute__((always_inline)) int inet_csk_reqsk_queue_is_full(const struct sock *sk)
{
 return reqsk_queue_is_full(&inet_csk(sk)->icsk_accept_queue);
}

static inline __attribute__((always_inline)) void inet_csk_reqsk_queue_unlink(struct sock *sk,
            struct request_sock *req,
            struct request_sock **prev)
{
 reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req, prev);
}

static inline __attribute__((always_inline)) void inet_csk_reqsk_queue_drop(struct sock *sk,
          struct request_sock *req,
          struct request_sock **prev)
{
 inet_csk_reqsk_queue_unlink(sk, req, prev);
 inet_csk_reqsk_queue_removed(sk, req);
 reqsk_free(req);
}

extern void inet_csk_reqsk_queue_prune(struct sock *parent,
           const unsigned long interval,
           const unsigned long timeout,
           const unsigned long max_rto);

extern void inet_csk_destroy_sock(struct sock *sk);




static inline __attribute__((always_inline)) unsigned int inet_csk_listen_poll(const struct sock *sk)
{
 return !reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue) ?
   (1 | 64) : 0;
}

extern int inet_csk_listen_start(struct sock *sk, const int nr_table_entries);
extern void inet_csk_listen_stop(struct sock *sk);

extern void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr);

extern int inet_csk_ctl_sock_create(struct socket **sock,
        unsigned short family,
        unsigned short type,
        unsigned char protocol);

extern int inet_csk_compat_getsockopt(struct sock *sk, int level, int optname,
          char *optval, int *optlen);
extern int inet_csk_compat_setsockopt(struct sock *sk, int level, int optname,
          char *optval, int optlen);
# 166 "include/linux/tcp.h" 2
# 1 "include/net/inet_timewait_sock.h" 1
# 27 "include/net/inet_timewait_sock.h"
# 1 "include/net/tcp_states.h" 1
# 16 "include/net/tcp_states.h"
enum {
 TCP_ESTABLISHED = 1,
 TCP_SYN_SENT,
 TCP_SYN_RECV,
 TCP_FIN_WAIT1,
 TCP_FIN_WAIT2,
 TCP_TIME_WAIT,
 TCP_CLOSE,
 TCP_CLOSE_WAIT,
 TCP_LAST_ACK,
 TCP_LISTEN,
 TCP_CLOSING,

 TCP_MAX_STATES
};





enum {
 TCPF_ESTABLISHED = (1 << 1),
 TCPF_SYN_SENT = (1 << 2),
 TCPF_SYN_RECV = (1 << 3),
 TCPF_FIN_WAIT1 = (1 << 4),
 TCPF_FIN_WAIT2 = (1 << 5),
 TCPF_TIME_WAIT = (1 << 6),
 TCPF_CLOSE = (1 << 7),
 TCPF_CLOSE_WAIT = (1 << 8),
 TCPF_LAST_ACK = (1 << 9),
 TCPF_LISTEN = (1 << 10),
 TCPF_CLOSING = (1 << 11)
};
# 28 "include/net/inet_timewait_sock.h" 2
# 1 "include/net/timewait_sock.h" 1
# 17 "include/net/timewait_sock.h"
struct timewait_sock_ops {
 kmem_cache_t *twsk_slab;
 unsigned int twsk_obj_size;
 int (*twsk_unique)(struct sock *sk,
           struct sock *sktw, void *twp);
 void (*twsk_destructor)(struct sock *sk);
};

static inline __attribute__((always_inline)) int twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
{
 if (sk->__sk_common.skc_prot->twsk_prot->twsk_unique != ((void *)0))
  return sk->__sk_common.skc_prot->twsk_prot->twsk_unique(sk, sktw, twp);
 return 0;
}

static inline __attribute__((always_inline)) void twsk_destructor(struct sock *sk)
{
 if (sk->__sk_common.skc_prot->twsk_prot->twsk_destructor != ((void *)0))
  sk->__sk_common.skc_prot->twsk_prot->twsk_destructor(sk);
}
# 29 "include/net/inet_timewait_sock.h" 2



struct inet_hashinfo;
# 66 "include/net/inet_timewait_sock.h"
struct inet_timewait_death_row {

 int twcal_hand;
 int twcal_jiffie;
 struct timer_list twcal_timer;
 struct hlist_head twcal_row[(1 << 5)];

 spinlock_t death_lock;
 int tw_count;
 int period;
 u32 thread_slots;
 struct work_struct twkill_work;
 struct timer_list tw_timer;
 int slot;
 struct hlist_head cells[8];
 struct inet_hashinfo *hashinfo;
 int sysctl_tw_recycle;
 int sysctl_max_tw_buckets;
};

extern void inet_twdr_hangman(unsigned long data);
extern void inet_twdr_twkill_work(void *data);
extern void inet_twdr_twcal_tick(unsigned long data);







struct inet_bind_bucket;






struct inet_timewait_sock {




 struct sock_common __tw_common;
# 118 "include/net/inet_timewait_sock.h"
 volatile unsigned char tw_substate;

 unsigned char tw_rcv_wscale;


 __be16 tw_sport;
 __be32 tw_daddr __attribute__((aligned(4)));
 __be32 tw_rcv_saddr;
 __be16 tw_dport;
 __u16 tw_num;

 __u8 tw_ipv6only:1;

 __u16 tw_ipv6_offset;
 int tw_timeout;
 unsigned long tw_ttd;
 struct inet_bind_bucket *tw_tb;
 struct hlist_node tw_death_node;
};

static inline __attribute__((always_inline)) void inet_twsk_add_node(struct inet_timewait_sock *tw,
          struct hlist_head *list)
{
 hlist_add_head(&tw->__tw_common.skc_node, list);
}

static inline __attribute__((always_inline)) void inet_twsk_add_bind_node(struct inet_timewait_sock *tw,
        struct hlist_head *list)
{
 hlist_add_head(&tw->__tw_common.skc_bind_node, list);
}

static inline __attribute__((always_inline)) int inet_twsk_dead_hashed(const struct inet_timewait_sock *tw)
{
 return !hlist_unhashed(&tw->tw_death_node);
}

static inline __attribute__((always_inline)) void inet_twsk_dead_node_init(struct inet_timewait_sock *tw)
{
 tw->tw_death_node.pprev = ((void *)0);
}

static inline __attribute__((always_inline)) void __inet_twsk_del_dead_node(struct inet_timewait_sock *tw)
{
 __hlist_del(&tw->tw_death_node);
 inet_twsk_dead_node_init(tw);
}

static inline __attribute__((always_inline)) int inet_twsk_del_dead_node(struct inet_timewait_sock *tw)
{
 if (inet_twsk_dead_hashed(tw)) {
  __inet_twsk_del_dead_node(tw);
  return 1;
 }
 return 0;
}
# 184 "include/net/inet_timewait_sock.h"
static inline __attribute__((always_inline)) struct inet_timewait_sock *inet_twsk(const struct sock *sk)
{
 return (struct inet_timewait_sock *)sk;
}

static inline __attribute__((always_inline)) __be32 inet_rcv_saddr(const struct sock *sk)
{
 return __builtin_expect(!!(sk->__sk_common.skc_state != TCP_TIME_WAIT), 1) ?
  inet_sk(sk)->rcv_saddr : inet_twsk(sk)->tw_rcv_saddr;
}

static inline __attribute__((always_inline)) void inet_twsk_put(struct inet_timewait_sock *tw)
{
 if ((atomic_sub_return(1, (&tw->__tw_common.skc_refcnt)) == 0)) {
  struct module *owner = tw->__tw_common.skc_prot->owner;
  twsk_destructor((struct sock *)tw);




  kmem_cache_free(tw->__tw_common.skc_prot->twsk_prot->twsk_slab, tw);
  module_put(owner);
 }
}

extern struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk,
        const int state);

extern void __inet_twsk_kill(struct inet_timewait_sock *tw,
        struct inet_hashinfo *hashinfo);

extern void __inet_twsk_hashdance(struct inet_timewait_sock *tw,
      struct sock *sk,
      struct inet_hashinfo *hashinfo);

extern void inet_twsk_schedule(struct inet_timewait_sock *tw,
          struct inet_timewait_death_row *twdr,
          const int timeo, const int timewait_len);
extern void inet_twsk_deschedule(struct inet_timewait_sock *tw,
     struct inet_timewait_death_row *twdr);
# 167 "include/linux/tcp.h" 2


struct tcp_sack_block_wire {
 __be32 start_seq;
 __be32 end_seq;
};

struct tcp_sack_block {
 __u32 start_seq;
 __u32 end_seq;
};

struct tcp_options_received {

 long ts_recent_stamp;
 __u32 ts_recent;
 __u32 rcv_tsval;
 __u32 rcv_tsecr;
 __u16 saw_tstamp : 1,
  tstamp_ok : 1,
  dsack : 1,
  wscale_ok : 1,
  sack_ok : 4,
  snd_wscale : 4,
  rcv_wscale : 4;

 __u8 eff_sacks;
 __u8 num_sacks;
 __u16 user_mss;
 __u16 mss_clamp;
};

struct tcp_request_sock {
 struct inet_request_sock req;
 __u32 rcv_isn;
 __u32 snt_isn;
};

static inline __attribute__((always_inline)) struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
{
 return (struct tcp_request_sock *)req;
}

struct tcp_sock {

 struct inet_connection_sock inet_conn;
 int tcp_header_len;





 __be32 pred_flags;






  __u32 rcv_nxt;
  __u32 snd_nxt;

  __u32 snd_una;
  __u32 snd_sml;
 __u32 rcv_tstamp;
 __u32 lsndtime;


 struct {
  struct sk_buff_head prequeue;
  struct task_struct *task;
  struct iovec *iov;
  int memory;
  int len;







 } ucopy;

 __u32 snd_wl1;
 __u32 snd_wnd;
 __u32 max_window;
 __u32 mss_cache;
 __u16 xmit_size_goal;


 __u32 window_clamp;
 __u32 rcv_ssthresh;

 __u32 frto_highmark;
 __u8 reordering;
 __u8 frto_counter;
 __u8 nonagle;
 __u8 keepalive_probes;


 __u32 srtt;
 __u32 mdev;
 __u32 mdev_max;
 __u32 rttvar;
 __u32 rtt_seq;

 __u32 packets_out;
 __u32 left_out;
 __u32 retrans_out;



 struct tcp_options_received rx_opt;




  __u32 snd_ssthresh;
  __u32 snd_cwnd;
  __u16 snd_cwnd_cnt;
 __u16 snd_cwnd_clamp;
 __u32 snd_cwnd_used;
 __u32 snd_cwnd_stamp;

 struct sk_buff_head out_of_order_queue;

  __u32 rcv_wnd;
 __u32 rcv_wup;
 __u32 write_seq;
 __u32 pushed_seq;
 __u32 copied_seq;


 struct tcp_sack_block duplicate_sack[1];
 struct tcp_sack_block selective_acks[4];

 struct tcp_sack_block recv_sack_cache[4];


 struct sk_buff* lost_skb_hint;

 struct sk_buff *scoreboard_skb_hint;
 struct sk_buff *retransmit_skb_hint;
 struct sk_buff *forward_skb_hint;
 struct sk_buff *fastpath_skb_hint;

 int fastpath_cnt_hint;
 int lost_cnt_hint;
 int retransmit_cnt_hint;
 int forward_cnt_hint;

 __u16 advmss;
 __u16 prior_ssthresh;
 __u32 lost_out;
 __u32 sacked_out;
 __u32 fackets_out;
 __u32 high_seq;

 __u32 retrans_stamp;


 __u32 undo_marker;
 int undo_retrans;
 __u32 urg_seq;
 __u16 urg_data;
 __u8 urg_mode;
 __u8 ecn_flags;
 __u32 snd_up;

 __u32 total_retrans;
 __u32 bytes_acked;

 unsigned int keepalive_time;
 unsigned int keepalive_intvl;
 int linger2;

 unsigned long last_synq_overflow;

 __u32 tso_deferred;


 struct {
  __u32 rtt;
  __u32 seq;
  __u32 time;
 } rcv_rtt_est;


 struct {
  int space;
  __u32 seq;
  __u32 time;
 } rcvq_space;


 struct {
  __u32 probe_seq_start;
  __u32 probe_seq_end;
 } mtu_probe;
};

static inline __attribute__((always_inline)) struct tcp_sock *tcp_sk(const struct sock *sk)
{
 return (struct tcp_sock *)sk;
}

struct tcp_timewait_sock {
 struct inet_timewait_sock tw_sk;
 __u32 tw_rcv_nxt;
 __u32 tw_snd_nxt;
 __u32 tw_rcv_wnd;
 __u32 tw_ts_recent;
 long tw_ts_recent_stamp;
};

static inline __attribute__((always_inline)) struct tcp_timewait_sock *tcp_twsk(const struct sock *sk)
{
 return (struct tcp_timewait_sock *)sk;
}
# 214 "include/linux/ipv6.h" 2
# 1 "include/linux/udp.h" 1
# 22 "include/linux/udp.h"
struct udphdr {
 __be16 source;
 __be16 dest;
 __be16 len;
 __be16 check;
};
# 42 "include/linux/udp.h"
struct udp_sock {

 struct inet_sock inet;
 int pending;
 unsigned int corkflag;
   __u16 encap_type;




 __u16 len;
};

static inline __attribute__((always_inline)) struct udp_sock *udp_sk(const struct sock *sk)
{
 return (struct udp_sock *)sk;
}
# 215 "include/linux/ipv6.h" 2

# 1 "include/net/if_inet6.h" 1
# 19 "include/net/if_inet6.h"
# 1 "include/linux/ipv6.h" 1
# 20 "include/net/if_inet6.h" 2
# 35 "include/net/if_inet6.h"
struct inet6_ifaddr
{
 struct in6_addr addr;
 __u32 prefix_len;

 __u32 valid_lft;
 __u32 prefered_lft;
 unsigned long cstamp;
 unsigned long tstamp;
 atomic_t refcnt;
 spinlock_t lock;

 __u8 probes;
 __u8 flags;

 __u16 scope;

 struct timer_list timer;

 struct inet6_dev *idev;
 struct rt6_info *rt;

 struct inet6_ifaddr *lst_next;
 struct inet6_ifaddr *if_next;







 int dead;
};

struct ip6_sf_socklist
{
 unsigned int sl_max;
 unsigned int sl_count;
 struct in6_addr sl_addr[0];
};






struct ipv6_mc_socklist
{
 struct in6_addr addr;
 int ifindex;
 struct ipv6_mc_socklist *next;
 rwlock_t sflock;
 unsigned int sfmode;
 struct ip6_sf_socklist *sflist;
};

struct ip6_sf_list
{
 struct ip6_sf_list *sf_next;
 struct in6_addr sf_addr;
 unsigned long sf_count[2];
 unsigned char sf_gsresp;
 unsigned char sf_oldin;
 unsigned char sf_crcount;
};







struct ifmcaddr6
{
 struct in6_addr mca_addr;
 struct inet6_dev *idev;
 struct ifmcaddr6 *next;
 struct ip6_sf_list *mca_sources;
 struct ip6_sf_list *mca_tomb;
 unsigned int mca_sfmode;
 unsigned long mca_sfcount[2];
 struct timer_list mca_timer;
 unsigned mca_flags;
 int mca_users;
 atomic_t mca_refcnt;
 spinlock_t mca_lock;
 unsigned char mca_crcount;
 unsigned long mca_cstamp;
 unsigned long mca_tstamp;
};



struct ipv6_ac_socklist
{
 struct in6_addr acl_addr;
 int acl_ifindex;
 struct ipv6_ac_socklist *acl_next;
};

struct ifacaddr6
{
 struct in6_addr aca_addr;
 struct inet6_dev *aca_idev;
 struct rt6_info *aca_rt;
 struct ifacaddr6 *aca_next;
 int aca_users;
 atomic_t aca_refcnt;
 spinlock_t aca_lock;
 unsigned long aca_cstamp;
 unsigned long aca_tstamp;
};






struct ipv6_devstat {
 struct proc_dir_entry *proc_dir_entry;
 __typeof__(struct icmpv6_mib) *icmpv6[2];
};

struct inet6_dev
{
 struct net_device *dev;

 struct inet6_ifaddr *addr_list;

 struct ifmcaddr6 *mc_list;
 struct ifmcaddr6 *mc_tomb;
 rwlock_t mc_lock;
 unsigned long mc_v1_seen;
 unsigned long mc_maxdelay;
 unsigned char mc_qrv;
 unsigned char mc_gq_running;
 unsigned char mc_ifc_count;
 struct timer_list mc_gq_timer;
 struct timer_list mc_ifc_timer;

 struct ifacaddr6 *ac_list;
 rwlock_t lock;
 atomic_t refcnt;
 __u32 if_flags;
 int dead;







 struct neigh_parms *nd_parms;
 struct inet6_dev *next;
 struct ipv6_devconf cnf;
 struct ipv6_devstat stats;
 unsigned long tstamp;
 struct rcu_head rcu;
};

extern struct ipv6_devconf ipv6_devconf;

static inline __attribute__((always_inline)) void ipv6_eth_mc_map(struct in6_addr *addr, char *buf)
{






 buf[0]= 0x33;
 buf[1]= 0x33;

 memcpy(buf + 2, &addr->in6_u.u6_addr32[3], sizeof(__u32));
}

static inline __attribute__((always_inline)) void ipv6_tr_mc_map(struct in6_addr *addr, char *buf)
{


 if (((addr->in6_u.u6_addr8[0] == 0xFF) &&
     ((addr->in6_u.u6_addr8[1] == 0x01) || (addr->in6_u.u6_addr8[1] == 0x02)) &&
      (addr->in6_u.u6_addr16[1] == 0) &&
      (addr->in6_u.u6_addr32[1] == 0) &&
      (addr->in6_u.u6_addr32[2] == 0) &&
      (addr->in6_u.u6_addr16[6] == 0) &&
      (addr->in6_u.u6_addr8[15] == 1)) ||
     ((addr->in6_u.u6_addr8[0] == 0xFF) &&
      (addr->in6_u.u6_addr8[1] == 0x02) &&
      (addr->in6_u.u6_addr16[1] == 0) &&
      (addr->in6_u.u6_addr32[1] == 0) &&
      (addr->in6_u.u6_addr16[4] == 0) &&
      (addr->in6_u.u6_addr8[10] == 0) &&
      (addr->in6_u.u6_addr8[11] == 1) &&
      (addr->in6_u.u6_addr8[12] == 0xff)))
 {
  buf[0]=0xC0;
  buf[1]=0x00;
  buf[2]=0x01;
  buf[3]=0x00;
  buf[4]=0x00;
  buf[5]=0x00;

 } else if ((addr->in6_u.u6_addr8[0] ==0xff) &&
  ((addr->in6_u.u6_addr8[1] & 0xF0) == 0) &&
  (addr->in6_u.u6_addr16[1] == 0) &&
  (addr->in6_u.u6_addr32[1] == 0) &&
  (addr->in6_u.u6_addr32[2] == 0) &&
  (addr->in6_u.u6_addr16[6] == 0) &&
  (addr->in6_u.u6_addr8[15] == 2))
 {
  buf[0]=0xC0;
  buf[1]=0x00;
  buf[2]=0x02;
  buf[3]=0x00;
  buf[4]=0x00;
  buf[5]=0x00;
 } else {
  unsigned char i ;

  i = addr->in6_u.u6_addr8[15] & 7 ;
  buf[0]=0xC0;
  buf[1]=0x00;
  buf[2]=0x00;
  buf[3]=0x01 << i ;
  buf[4]=0x00;
  buf[5]=0x00;
 }
}

static inline __attribute__((always_inline)) void ipv6_arcnet_mc_map(const struct in6_addr *addr, char *buf)
{
 buf[0] = 0x00;
}

static inline __attribute__((always_inline)) void ipv6_ib_mc_map(struct in6_addr *addr, char *buf)
{
 buf[0] = 0;
 buf[1] = 0xff;
 buf[2] = 0xff;
 buf[3] = 0xff;
 buf[4] = 0xff;
 buf[5] = 0x12;
 buf[6] = 0x60;
 buf[7] = 0x1b;
 buf[8] = 0;
 buf[9] = 0;
 memcpy(buf + 10, addr->in6_u.u6_addr8 + 6, 10);
}
# 217 "include/linux/ipv6.h" 2







struct inet6_skb_parm {
 int iif;
 __u16 ra;
 __u16 hop;
 __u16 dst0;
 __u16 srcrt;
 __u16 dst1;
 __u16 lastopt;
 __u32 nhoff;
 __u16 flags;





};



static inline __attribute__((always_inline)) int inet6_iif(const struct sk_buff *skb)
{
 return ((struct inet6_skb_parm*)((skb)->cb))->iif;
}

struct inet6_request_sock {
 struct in6_addr loc_addr;
 struct in6_addr rmt_addr;
 struct sk_buff *pktopts;
 int iif;
};

struct tcp6_request_sock {
 struct tcp_request_sock tcp6rsk_tcp;
 struct inet6_request_sock tcp6rsk_inet6;
};
# 268 "include/linux/ipv6.h"
struct ipv6_pinfo {
 struct in6_addr saddr;
 struct in6_addr rcv_saddr;
 struct in6_addr daddr;
 struct in6_addr *daddr_cache;




 __u32 flow_label;
 __u32 frag_size;
 __s16 hop_limit;
 __s16 mcast_hops;
 int mcast_oif;


 union {
  struct {
   __u16 srcrt:2,
    osrcrt:2,
           rxinfo:1,
           rxoinfo:1,
    rxhlim:1,
    rxohlim:1,
    hopopts:1,
    ohopopts:1,
    dstopts:1,
    odstopts:1,
                                rxflow:1,
    rxtclass:1;
  } bits;
  __u16 all;
 } rxopt;


 __u8 mc_loop:1,
                         recverr:1,
                         sndflow:1,
    pmtudisc:2,
    ipv6only:1;
 __u8 tclass;

 __u32 dst_cookie;

 struct ipv6_mc_socklist *ipv6_mc_list;
 struct ipv6_ac_socklist *ipv6_ac_list;
 struct ipv6_fl_socklist *ipv6_fl_list;

 struct ipv6_txoptions *opt;
 struct sk_buff *pktoptions;
 struct {
  struct ipv6_txoptions *opt;
  struct rt6_info *rt;
  int hop_limit;
  int tclass;
 } cork;
};


struct raw6_sock {

 struct inet_sock inet;
 __u32 checksum;
 __u32 offset;
 struct icmp6_filter filter;

 struct ipv6_pinfo inet6;
};

struct udp6_sock {
 struct udp_sock udp;

 struct ipv6_pinfo inet6;
};

struct tcp6_sock {
 struct tcp_sock tcp;

 struct ipv6_pinfo inet6;
};

extern int inet6_sk_rebuild_header(struct sock *sk);
# 440 "include/linux/ipv6.h"
static inline __attribute__((always_inline)) struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) struct inet6_request_sock *
   inet6_rsk(const struct request_sock *rsk)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) struct raw6_sock *raw6_sk(const struct sock *sk)
{
 return ((void *)0);
}
# 19 "include/net/ipv6.h" 2

# 1 "include/net/ndisc.h" 1
# 18 "include/net/ndisc.h"
enum {
 __ND_OPT_PREFIX_INFO_END = 0,
 ND_OPT_SOURCE_LL_ADDR = 1,
 ND_OPT_TARGET_LL_ADDR = 2,
 ND_OPT_PREFIX_INFO = 3,
 ND_OPT_REDIRECT_HDR = 4,
 ND_OPT_MTU = 5,
 __ND_OPT_ARRAY_MAX,
 ND_OPT_ROUTE_INFO = 24,
 __ND_OPT_MAX
};
# 47 "include/net/ndisc.h"
struct ctl_table;
struct file;
struct inet6_dev;
struct net_device;
struct net_proto_family;
struct sk_buff;

extern struct neigh_table nd_tbl;

struct nd_msg {
        struct icmp6hdr icmph;
        struct in6_addr target;
 __u8 opt[0];
};

struct rs_msg {
 struct icmp6hdr icmph;
 __u8 opt[0];
};

struct ra_msg {
        struct icmp6hdr icmph;
 __u32 reachable_time;
 __u32 retrans_timer;
};

struct nd_opt_hdr {
 __u8 nd_opt_type;
 __u8 nd_opt_len;
} __attribute__((__packed__));


extern int ndisc_init(struct net_proto_family *ops);

extern void ndisc_cleanup(void);

extern int ndisc_rcv(struct sk_buff *skb);

extern void ndisc_send_ns(struct net_device *dev,
           struct neighbour *neigh,
           struct in6_addr *solicit,
           struct in6_addr *daddr,
           struct in6_addr *saddr);

extern void ndisc_send_rs(struct net_device *dev,
           struct in6_addr *saddr,
           struct in6_addr *daddr);

extern void ndisc_forwarding_on(void);
extern void ndisc_forwarding_off(void);

extern void ndisc_send_redirect(struct sk_buff *skb,
          struct neighbour *neigh,
          struct in6_addr *target);

extern int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir);


struct rt6_info * dflt_rt_lookup(void);




extern int igmp6_init(struct net_proto_family *ops);

extern void igmp6_cleanup(void);

extern int igmp6_event_query(struct sk_buff *skb);

extern int igmp6_event_report(struct sk_buff *skb);

extern void igmp6_cleanup(void);


extern int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl,
          int write,
          struct file * filp,
          void *buffer,
          size_t *lenp,
          loff_t *ppos);


extern void inet6_ifinfo_notify(int event,
          struct inet6_dev *idev);

static inline __attribute__((always_inline)) struct neighbour * ndisc_get_neigh(struct net_device *dev, struct in6_addr *addr)
{

 if (dev)
  return __neigh_lookup(&nd_tbl, addr, dev, 1);

 return ((void *)0);
}
# 21 "include/net/ipv6.h" 2
# 97 "include/net/ipv6.h"
struct frag_hdr {
 unsigned char nexthdr;
 unsigned char reserved;
 unsigned short frag_off;
 __u32 identification;
};
# 111 "include/net/ipv6.h"
extern int sysctl_ipv6_bindv6only;
extern int sysctl_mld_max_msf;


extern __typeof__(struct ipstats_mib) *ipv6_statistics[2];



extern __typeof__(struct icmpv6_mib) *icmpv6_statistics[2];
# 145 "include/net/ipv6.h"
extern __typeof__(struct udp_mib) *udp_stats_in6[2];




int snmp6_register_dev(struct inet6_dev *idev);
int snmp6_unregister_dev(struct inet6_dev *idev);
int snmp6_alloc_dev(struct inet6_dev *idev);
int snmp6_free_dev(struct inet6_dev *idev);
int snmp6_mib_init(void *ptr[2], size_t mibsize, size_t mibalign);
void snmp6_mib_free(void *ptr[2]);

struct ip6_ra_chain
{
 struct ip6_ra_chain *next;
 struct sock *sk;
 int sel;
 void (*destructor)(struct sock *);
};

extern struct ip6_ra_chain *ip6_ra_chain;
extern rwlock_t ip6_ra_lock;






struct ipv6_txoptions
{

 int tot_len;



 __u16 opt_flen;
 __u16 opt_nflen;

 struct ipv6_opt_hdr *hopopt;
 struct ipv6_opt_hdr *dst0opt;
 struct ipv6_rt_hdr *srcrt;
 struct ipv6_opt_hdr *dst1opt;


};

struct ip6_flowlabel
{
 struct ip6_flowlabel *next;
 u32 label;
 struct in6_addr dst;
 struct ipv6_txoptions *opt;
 atomic_t users;
 unsigned long linger;
 u8 share;
 u32 owner;
 unsigned long lastuse;
 unsigned long expires;
};




struct ipv6_fl_socklist
{
 struct ipv6_fl_socklist *next;
 struct ip6_flowlabel *fl;
};

extern struct ip6_flowlabel *fl6_sock_lookup(struct sock *sk, u32 label);
extern struct ipv6_txoptions *fl6_merge_options(struct ipv6_txoptions * opt_space,
         struct ip6_flowlabel * fl,
         struct ipv6_txoptions * fopt);
extern void fl6_free_socklist(struct sock *sk);
extern int ipv6_flowlabel_opt(struct sock *sk, char *optval, int optlen);
extern void ip6_flowlabel_init(void);
extern void ip6_flowlabel_cleanup(void);

static inline __attribute__((always_inline)) void fl6_sock_release(struct ip6_flowlabel *fl)
{
 if (fl)
  atomic_dec(&fl->users);
}

extern int ip6_ra_control(struct sock *sk, int sel,
            void (*destructor)(struct sock *));


extern int ipv6_parse_hopopts(struct sk_buff **skbp);

extern struct ipv6_txoptions * ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt);
extern struct ipv6_txoptions * ipv6_renew_options(struct sock *sk, struct ipv6_txoptions *opt,
         int newtype,
         struct ipv6_opt_hdr *newopt,
         int newoptlen);
struct ipv6_txoptions *ipv6_fixup_options(struct ipv6_txoptions *opt_space,
       struct ipv6_txoptions *opt);

extern int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb);

extern int ip6_frag_nqueues;
extern atomic_t ip6_frag_mem;







typedef int (*inet_getfrag_t) (const void *data,
        struct in6_addr *addr,
        char *,
        unsigned int, unsigned int);

extern int __ipv6_addr_type(const struct in6_addr *addr);
static inline __attribute__((always_inline)) int ipv6_addr_type(const struct in6_addr *addr)
{
 return __ipv6_addr_type(addr) & 0xffff;
}

static inline __attribute__((always_inline)) int ipv6_addr_scope(const struct in6_addr *addr)
{
 return __ipv6_addr_type(addr) & 0x00f0U;
}

static inline __attribute__((always_inline)) int __ipv6_addr_src_scope(int type)
{
 return (type == 0x0000U ? -1 : (type >> 16));
}

static inline __attribute__((always_inline)) int ipv6_addr_src_scope(const struct in6_addr *addr)
{
 return __ipv6_addr_src_scope(__ipv6_addr_type(addr));
}

static inline __attribute__((always_inline)) int ipv6_addr_cmp(const struct in6_addr *a1, const struct in6_addr *a2)
{
 return memcmp((const void *) a1, (const void *) a2, sizeof(struct in6_addr));
}

static inline __attribute__((always_inline)) int
ipv6_masked_addr_cmp(const struct in6_addr *a1, const struct in6_addr *m,
       const struct in6_addr *a2)
{
 unsigned int i;

 for (i = 0; i < 4; i++)
  if ((a1->in6_u.u6_addr32[i] ^ a2->in6_u.u6_addr32[i]) & m->in6_u.u6_addr32[i])
   return 1;
 return 0;
}

static inline __attribute__((always_inline)) void ipv6_addr_copy(struct in6_addr *a1, const struct in6_addr *a2)
{
 memcpy((void *) a1, (const void *) a2, sizeof(struct in6_addr));
}

static inline __attribute__((always_inline)) void ipv6_addr_prefix(struct in6_addr *pfx,
        const struct in6_addr *addr,
        int plen)
{

 int o = plen >> 3,
     b = plen & 0x7;

 memcpy(pfx->in6_u.u6_addr8, addr, o);
 if (b != 0) {
  pfx->in6_u.u6_addr8[o] = addr->in6_u.u6_addr8[o] & (0xff00 >> b);
  o++;
 }
 if (o < 16)
  memset(pfx->in6_u.u6_addr8 + o, 0, 16 - o);
}


static inline __attribute__((always_inline)) void ipv6_addr_set(struct in6_addr *addr,
         __be32 w1, __be32 w2,
         __be32 w3, __be32 w4)
{
 addr->in6_u.u6_addr32[0] = w1;
 addr->in6_u.u6_addr32[1] = w2;
 addr->in6_u.u6_addr32[2] = w3;
 addr->in6_u.u6_addr32[3] = w4;
}


static inline __attribute__((always_inline)) int ipv6_addr_equal(const struct in6_addr *a1,
      const struct in6_addr *a2)
{
 return (a1->in6_u.u6_addr32[0] == a2->in6_u.u6_addr32[0] &&
  a1->in6_u.u6_addr32[1] == a2->in6_u.u6_addr32[1] &&
  a1->in6_u.u6_addr32[2] == a2->in6_u.u6_addr32[2] &&
  a1->in6_u.u6_addr32[3] == a2->in6_u.u6_addr32[3]);
}

static inline __attribute__((always_inline)) int __ipv6_prefix_equal(const __be32 *a1, const __be32 *a2,
          unsigned int prefixlen)
{
 unsigned pdw, pbi;


 pdw = prefixlen >> 5;
 if (pdw && memcmp(a1, a2, pdw << 2))
  return 0;


 pbi = prefixlen & 0x1f;
 if (pbi && ((a1[pdw] ^ a2[pdw]) & htonl((0xffffffff) << (32 - pbi))))
  return 0;

 return 1;
}

static inline __attribute__((always_inline)) int ipv6_prefix_equal(const struct in6_addr *a1,
        const struct in6_addr *a2,
        unsigned int prefixlen)
{
 return __ipv6_prefix_equal(a1->in6_u.u6_addr32, a2->in6_u.u6_addr32,
       prefixlen);
}

static inline __attribute__((always_inline)) int ipv6_addr_any(const struct in6_addr *a)
{
 return ((a->in6_u.u6_addr32[0] | a->in6_u.u6_addr32[1] |
   a->in6_u.u6_addr32[2] | a->in6_u.u6_addr32[3] ) == 0);
}





static inline __attribute__((always_inline)) int __ipv6_addr_diff(const void *token1, const void *token2, int addrlen)
{
 const __u32 *a1 = token1, *a2 = token2;
 int i;

 addrlen >>= 2;

 for (i = 0; i < addrlen; i++) {
  __u32 xb = a1[i] ^ a2[i];
  if (xb) {
   int j = 31;

   xb = ntohl(xb);
   while ((xb & (1 << j)) == 0)
    j--;

   return (i * 32 + 31 - j);
  }
 }
# 412 "include/net/ipv6.h"
 return (addrlen << 5);
}

static inline __attribute__((always_inline)) int ipv6_addr_diff(const struct in6_addr *a1, const struct in6_addr *a2)
{
 return __ipv6_addr_diff(a1, a2, sizeof(struct in6_addr));
}
# 428 "include/net/ipv6.h"
extern int ipv6_rcv(struct sk_buff *skb,
      struct net_device *dev,
      struct packet_type *pt,
      struct net_device *orig_dev);

extern int ip6_rcv_finish(struct sk_buff *skb);




extern int ip6_xmit(struct sock *sk,
      struct sk_buff *skb,
      struct flowi *fl,
      struct ipv6_txoptions *opt,
      int ipfragok);

extern int ip6_nd_hdr(struct sock *sk,
        struct sk_buff *skb,
        struct net_device *dev,
        struct in6_addr *saddr,
        struct in6_addr *daddr,
        int proto, int len);

extern int ip6_find_1stfragopt(struct sk_buff *skb, u8 **nexthdr);

extern int ip6_append_data(struct sock *sk,
      int getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb),
          void *from,
      int length,
      int transhdrlen,
            int hlimit,
            int tclass,
      struct ipv6_txoptions *opt,
      struct flowi *fl,
      struct rt6_info *rt,
      unsigned int flags);

extern int ip6_push_pending_frames(struct sock *sk);

extern void ip6_flush_pending_frames(struct sock *sk);

extern int ip6_dst_lookup(struct sock *sk,
            struct dst_entry **dst,
            struct flowi *fl);
extern int ip6_sk_dst_lookup(struct sock *sk,
        struct dst_entry **dst,
        struct flowi *fl);





extern int ip6_output(struct sk_buff *skb);
extern int ip6_forward(struct sk_buff *skb);
extern int ip6_input(struct sk_buff *skb);
extern int ip6_mc_input(struct sk_buff *skb);





extern u8 * ipv6_build_nfrag_opts(struct sk_buff *skb,
            u8 *prev_hdr,
            struct ipv6_txoptions *opt,
            struct in6_addr *daddr,
            u32 jumbolen);
extern u8 * ipv6_build_frag_opts(struct sk_buff *skb,
           u8 *prev_hdr,
           struct ipv6_txoptions *opt);
extern void ipv6_push_nfrag_opts(struct sk_buff *skb,
           struct ipv6_txoptions *opt,
           u8 *proto,
           struct in6_addr **daddr_p);
extern void ipv6_push_frag_opts(struct sk_buff *skb,
          struct ipv6_txoptions *opt,
          u8 *proto);

extern int ipv6_skip_exthdr(const struct sk_buff *, int start,
              u8 *nexthdrp);

extern int ipv6_ext_hdr(u8 nexthdr);

extern int ipv6_find_tlv(struct sk_buff *skb, int offset, int type);

extern struct ipv6_txoptions * ipv6_invert_rthdr(struct sock *sk,
        struct ipv6_rt_hdr *hdr);






extern int ipv6_setsockopt(struct sock *sk, int level,
      int optname,
      char *optval,
      int optlen);
extern int ipv6_getsockopt(struct sock *sk, int level,
      int optname,
      char *optval,
      int *optlen);
extern int compat_ipv6_setsockopt(struct sock *sk,
      int level,
      int optname,
      char *optval,
      int optlen);
extern int compat_ipv6_getsockopt(struct sock *sk,
      int level,
      int optname,
      char *optval,
      int *optlen);

extern void ipv6_packet_init(void);

extern void ipv6_packet_cleanup(void);

extern int ip6_datagram_connect(struct sock *sk,
           struct sockaddr *addr, int addr_len);

extern int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len);
extern void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err, u16 port,
      u32 info, u8 *payload);
extern void ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info);

extern int inet6_release(struct socket *sock);
extern int inet6_bind(struct socket *sock, struct sockaddr *uaddr,
        int addr_len);
extern int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
    int *uaddr_len, int peer);
extern int inet6_ioctl(struct socket *sock, unsigned int cmd,
         unsigned long arg);

extern int inet6_hash_connect(struct inet_timewait_death_row *death_row,
         struct sock *sk);




extern int sysctl_ip6frag_high_thresh;
extern int sysctl_ip6frag_low_thresh;
extern int sysctl_ip6frag_time;
extern int sysctl_ip6frag_secret_interval;

extern const struct proto_ops inet6_stream_ops;
extern const struct proto_ops inet6_dgram_ops;

struct group_source_req;
struct group_filter;

extern int ip6_mc_source(int add, int omode, struct sock *sk,
    struct group_source_req *pgsr);
extern int ip6_mc_msfilter(struct sock *sk, struct group_filter *gsf);
extern int ip6_mc_msfget(struct sock *sk, struct group_filter *gsf,
    struct group_filter *optval,
    int *optlen);


extern int ac6_proc_init(void);
extern void ac6_proc_exit(void);
extern int raw6_proc_init(void);
extern void raw6_proc_exit(void);
extern int tcp6_proc_init(void);
extern void tcp6_proc_exit(void);
extern int udp6_proc_init(void);
extern void udp6_proc_exit(void);
extern int ipv6_misc_proc_init(void);
extern void ipv6_misc_proc_exit(void);

extern struct rt6_statistics rt6_stats;



extern ctl_table ipv6_route_table[];
extern ctl_table ipv6_icmp_table[];

extern void ipv6_sysctl_register(void);
extern void ipv6_sysctl_unregister(void);
# 20 "include/net/xfrm.h" 2
# 1 "include/net/ip6_fib.h" 1
# 18 "include/net/ip6_fib.h"
# 1 "include/linux/ipv6_route.h" 1
# 42 "include/linux/ipv6_route.h"
struct in6_rtmsg {
 struct in6_addr rtmsg_dst;
 struct in6_addr rtmsg_src;
 struct in6_addr rtmsg_gateway;
 __u32 rtmsg_type;
 __u16 rtmsg_dst_len;
 __u16 rtmsg_src_len;
 __u32 rtmsg_metric;
 unsigned long rtmsg_info;
        __u32 rtmsg_flags;
 int rtmsg_ifindex;
};
# 19 "include/net/ip6_fib.h" 2




# 1 "include/net/netlink.h" 1
# 162 "include/net/netlink.h"
enum {
 NLA_UNSPEC,
 NLA_U8,
 NLA_U16,
 NLA_U32,
 NLA_U64,
 NLA_STRING,
 NLA_FLAG,
 NLA_MSECS,
 NLA_NESTED,
 NLA_NUL_STRING,
 __NLA_TYPE_MAX,
};
# 199 "include/net/netlink.h"
struct nla_policy {
 u16 type;
 u16 len;
};






struct nl_info {
 struct nlmsghdr *nlh;
 u32 pid;
};

extern void netlink_run_queue(struct sock *sk, unsigned int *qlen,
       int (*cb)(struct sk_buff *,
          struct nlmsghdr *, int *));
extern void netlink_queue_skip(struct nlmsghdr *nlh,
        struct sk_buff *skb);
extern int nlmsg_notify(struct sock *sk, struct sk_buff *skb,
         u32 pid, unsigned int group, int report,
         gfp_t flags);

extern int nla_validate(struct nlattr *head, int len, int maxtype,
         struct nla_policy *policy);
extern int nla_parse(struct nlattr *tb[], int maxtype,
      struct nlattr *head, int len,
      struct nla_policy *policy);
extern struct nlattr * nla_find(struct nlattr *head, int len, int attrtype);
extern size_t nla_strlcpy(char *dst, const struct nlattr *nla,
        size_t dstsize);
extern int nla_memcpy(void *dest, struct nlattr *src, int count);
extern int nla_memcmp(const struct nlattr *nla, const void *data,
       size_t size);
extern int nla_strcmp(const struct nlattr *nla, const char *str);
extern struct nlattr * __nla_reserve(struct sk_buff *skb, int attrtype,
          int attrlen);
extern void * __nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
extern struct nlattr * nla_reserve(struct sk_buff *skb, int attrtype,
        int attrlen);
extern void * nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
extern void __nla_put(struct sk_buff *skb, int attrtype,
      int attrlen, const void *data);
extern void __nla_put_nohdr(struct sk_buff *skb, int attrlen,
     const void *data);
extern int nla_put(struct sk_buff *skb, int attrtype,
    int attrlen, const void *data);
extern int nla_put_nohdr(struct sk_buff *skb, int attrlen,
          const void *data);
# 258 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_msg_size(int payload)
{
 return ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )) + payload;
}





static inline __attribute__((always_inline)) int nlmsg_total_size(int payload)
{
 return ( ((nlmsg_msg_size(payload))+4 -1) & ~(4 -1) );
}





static inline __attribute__((always_inline)) int nlmsg_padlen(int payload)
{
 return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
}





static inline __attribute__((always_inline)) void *nlmsg_data(const struct nlmsghdr *nlh)
{
 return (unsigned char *) nlh + ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) ));
}





static inline __attribute__((always_inline)) int nlmsg_len(const struct nlmsghdr *nlh)
{
 return nlh->nlmsg_len - ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) ));
}






static inline __attribute__((always_inline)) struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
         int hdrlen)
{
 unsigned char *data = nlmsg_data(nlh);
 return (struct nlattr *) (data + ( ((hdrlen)+4 -1) & ~(4 -1) ));
}






static inline __attribute__((always_inline)) int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
{
 return nlmsg_len(nlh) - ( ((hdrlen)+4 -1) & ~(4 -1) );
}






static inline __attribute__((always_inline)) int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
{
 return (remaining >= sizeof(struct nlmsghdr) &&
  nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
  nlh->nlmsg_len <= remaining);
}
# 341 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
{
 int totlen = ( ((nlh->nlmsg_len)+4 -1) & ~(4 -1) );

 *remaining -= totlen;

 return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
}
# 360 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen,
         struct nlattr *tb[], int maxtype,
         struct nla_policy *policy)
{
 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
  return -22;

 return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
    nlmsg_attrlen(nlh, hdrlen), policy);
}
# 379 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlattr *nlmsg_find_attr(struct nlmsghdr *nlh,
          int hdrlen, int attrtype)
{
 return nla_find(nlmsg_attrdata(nlh, hdrlen),
   nlmsg_attrlen(nlh, hdrlen), attrtype);
}
# 393 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
     struct nla_policy *policy)
{
 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
  return -22;

 return nla_validate(nlmsg_attrdata(nlh, hdrlen),
       nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
}







static inline __attribute__((always_inline)) int nlmsg_report(struct nlmsghdr *nlh)
{
 return !!(nlh->nlmsg_flags & 8);
}
# 472 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
      int type, int payload, int flags)
{
 if (__builtin_expect(!!(skb_tailroom(skb) < nlmsg_total_size(payload)), 0))
  return ((void *)0);

 return __nlmsg_put(skb, pid, seq, type, payload, flags);
}
# 492 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
      struct netlink_callback *cb,
      int type, int payload,
      int flags)
{
 return nlmsg_put(skb, (*(struct netlink_skb_parms*)&((cb->skb)->cb)).pid, cb->nlh->nlmsg_seq,
    type, payload, flags);
}
# 508 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct sk_buff *nlmsg_new(int size, gfp_t flags)
{
 return alloc_skb(size, flags);
}
# 524 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
{
 nlh->nlmsg_len = skb->tail - (unsigned char *) nlh;

 return skb->len;
}







static inline __attribute__((always_inline)) void *nlmsg_get_pos(struct sk_buff *skb)
{
 return skb->tail;
}
# 549 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_trim(struct sk_buff *skb, void *mark)
{
 if (mark)
  skb_trim(skb, (unsigned char *) mark - skb->data);

 return -1;
}
# 565 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
{
 return nlmsg_trim(skb, nlh);
}





static inline __attribute__((always_inline)) void nlmsg_free(struct sk_buff *skb)
{
 kfree_skb(skb);
}
# 587 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
      u32 pid, unsigned int group, gfp_t flags)
{
 int err;

 (*(struct netlink_skb_parms*)&((skb)->cb)).dst_group = group;

 err = netlink_broadcast(sk, skb, pid, group, flags);
 if (err > 0)
  err = 0;

 return err;
}







static inline __attribute__((always_inline)) int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 pid)
{
 int err;

 err = netlink_unicast(sk, skb, pid, 0x40);
 if (err > 0)
  err = 0;

 return err;
}
# 638 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nla_attr_size(int payload)
{
 return ((int) (((sizeof(struct nlattr)) + 4 - 1) & ~(4 - 1))) + payload;
}





static inline __attribute__((always_inline)) int nla_total_size(int payload)
{
 return (((nla_attr_size(payload)) + 4 - 1) & ~(4 - 1));
}





static inline __attribute__((always_inline)) int nla_padlen(int payload)
{
 return nla_total_size(payload) - nla_attr_size(payload);
}





static inline __attribute__((always_inline)) void *nla_data(const struct nlattr *nla)
{
 return (char *) nla + ((int) (((sizeof(struct nlattr)) + 4 - 1) & ~(4 - 1)));
}





static inline __attribute__((always_inline)) int nla_len(const struct nlattr *nla)
{
 return nla->nla_len - ((int) (((sizeof(struct nlattr)) + 4 - 1) & ~(4 - 1)));
}






static inline __attribute__((always_inline)) int nla_ok(const struct nlattr *nla, int remaining)
{
 return remaining >= sizeof(*nla) &&
        nla->nla_len >= sizeof(*nla) &&
        nla->nla_len <= remaining;
}
# 699 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
{
 int totlen = (((nla->nla_len) + 4 - 1) & ~(4 - 1));

 *remaining -= totlen;
 return (struct nlattr *) ((char *) nla + totlen);
}
# 714 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlattr *nla_find_nested(struct nlattr *nla, int attrtype)
{
 return nla_find(nla_data(nla), nla_len(nla), attrtype);
}
# 728 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nla_parse_nested(struct nlattr *tb[], int maxtype,
       struct nlattr *nla,
       struct nla_policy *policy)
{
 return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
}






static inline __attribute__((always_inline)) int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
{
 return nla_put(skb, attrtype, sizeof(u8), &value);
}







static inline __attribute__((always_inline)) int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
{
 return nla_put(skb, attrtype, sizeof(u16), &value);
}







static inline __attribute__((always_inline)) int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
{
 return nla_put(skb, attrtype, sizeof(u32), &value);
}







static inline __attribute__((always_inline)) int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
{
 return nla_put(skb, attrtype, sizeof(u64), &value);
}







static inline __attribute__((always_inline)) int nla_put_string(struct sk_buff *skb, int attrtype,
     const char *str)
{
 return nla_put(skb, attrtype, strlen(str) + 1, str);
}






static inline __attribute__((always_inline)) int nla_put_flag(struct sk_buff *skb, int attrtype)
{
 return nla_put(skb, attrtype, 0, ((void *)0));
}







static inline __attribute__((always_inline)) int nla_put_msecs(struct sk_buff *skb, int attrtype,
    unsigned long jiffies)
{
 u64 tmp = jiffies_to_msecs(jiffies);
 return nla_put(skb, attrtype, sizeof(u64), &tmp);
}
# 853 "include/net/netlink.h"
static inline __attribute__((always_inline)) u32 nla_get_u32(struct nlattr *nla)
{
 return *(u32 *) nla_data(nla);
}





static inline __attribute__((always_inline)) __be32 nla_get_be32(struct nlattr *nla)
{
 return *(__be32 *) nla_data(nla);
}





static inline __attribute__((always_inline)) u16 nla_get_u16(struct nlattr *nla)
{
 return *(u16 *) nla_data(nla);
}





static inline __attribute__((always_inline)) u8 nla_get_u8(struct nlattr *nla)
{
 return *(u8 *) nla_data(nla);
}





static inline __attribute__((always_inline)) u64 nla_get_u64(struct nlattr *nla)
{
 u64 tmp;

 nla_memcpy(&tmp, nla, sizeof(tmp));

 return tmp;
}





static inline __attribute__((always_inline)) int nla_get_flag(struct nlattr *nla)
{
 return !!nla;
}







static inline __attribute__((always_inline)) unsigned long nla_get_msecs(struct nlattr *nla)
{
 u64 msecs = nla_get_u64(nla);

 return msecs_to_jiffies((unsigned long) msecs);
}
# 927 "include/net/netlink.h"
static inline __attribute__((always_inline)) struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
{
 struct nlattr *start = (struct nlattr *) skb->tail;

 if (nla_put(skb, attrtype, 0, ((void *)0)) < 0)
  return ((void *)0);

 return start;
}
# 947 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
{
 start->nla_len = skb->tail - (unsigned char *) start;
 return skb->len;
}
# 961 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
{
 return nlmsg_trim(skb, start);
}
# 978 "include/net/netlink.h"
static inline __attribute__((always_inline)) int nla_validate_nested(struct nlattr *start, int maxtype,
          struct nla_policy *policy)
{
 return nla_validate(nla_data(start), nla_len(start), maxtype, policy);
}
# 24 "include/net/ip6_fib.h" 2

struct rt6_info;

struct fib6_config
{
 u32 fc_table;
 u32 fc_metric;
 int fc_dst_len;
 int fc_src_len;
 int fc_ifindex;
 u32 fc_flags;
 u32 fc_protocol;

 struct in6_addr fc_dst;
 struct in6_addr fc_src;
 struct in6_addr fc_gateway;

 unsigned long fc_expires;
 struct nlattr *fc_mx;
 int fc_mx_len;

 struct nl_info fc_nlinfo;
};

struct fib6_node
{
 struct fib6_node *parent;
 struct fib6_node *left;
 struct fib6_node *right;

 struct fib6_node *subtree;

 struct rt6_info *leaf;

 __u16 fn_bit;
 __u16 fn_flags;
 __u32 fn_sernum;
};
# 74 "include/net/ip6_fib.h"
struct rt6key
{
 struct in6_addr addr;
 int plen;
};

struct fib6_table;

struct rt6_info
{
 union {
  struct dst_entry dst;
  struct rt6_info *next;
 } u;

 struct inet6_dev *rt6i_idev;





 struct fib6_node *rt6i_node;

 struct in6_addr rt6i_gateway;

 u32 rt6i_flags;
 u32 rt6i_metric;
 atomic_t rt6i_ref;
 struct fib6_table *rt6i_table;

 struct rt6key rt6i_dst;
 struct rt6key rt6i_src;

 u8 rt6i_protocol;
};

struct fib6_walker_t
{
 struct fib6_walker_t *prev, *next;
 struct fib6_node *root, *node;
 struct rt6_info *leaf;
 unsigned char state;
 unsigned char prune;
 int (*func)(struct fib6_walker_t *);
 void *args;
};

struct rt6_statistics {
 __u32 fib_nodes;
 __u32 fib_route_nodes;
 __u32 fib_rt_alloc;
 __u32 fib_rt_entries;
 __u32 fib_rt_cache;
 __u32 fib_discarded_routes;
};
# 151 "include/net/ip6_fib.h"
typedef void (*f_pnode)(struct fib6_node *fn, void *);

struct fib6_table {
 struct hlist_node tb6_hlist;
 u32 tb6_id;
 rwlock_t tb6_lock;
 struct fib6_node tb6_root;
};
# 176 "include/net/ip6_fib.h"
typedef struct rt6_info *(*pol_lookup_t)(struct fib6_table *,
      struct flowi *, int);





extern struct fib6_table * fib6_get_table(u32 id);
extern struct fib6_table * fib6_new_table(u32 id);
extern struct dst_entry * fib6_rule_lookup(struct flowi *fl, int flags,
       pol_lookup_t lookup);

extern struct fib6_node *fib6_lookup(struct fib6_node *root,
          struct in6_addr *daddr,
          struct in6_addr *saddr);

struct fib6_node *fib6_locate(struct fib6_node *root,
          struct in6_addr *daddr, int dst_len,
          struct in6_addr *saddr, int src_len);

extern void fib6_clean_all(int (*func)(struct rt6_info *, void *arg),
            int prune, void *arg);

extern int fib6_add(struct fib6_node *root,
      struct rt6_info *rt,
      struct nl_info *info);

extern int fib6_del(struct rt6_info *rt,
      struct nl_info *info);

extern void inet6_rt_notify(int event, struct rt6_info *rt,
      struct nl_info *info);

extern void fib6_run_gc(unsigned long dummy);

extern void fib6_gc_cleanup(void);

extern void fib6_init(void);

extern void fib6_rules_init(void);
extern void fib6_rules_cleanup(void);
extern int fib6_rules_dump(struct sk_buff *,
      struct netlink_callback *);
# 21 "include/net/xfrm.h" 2





extern struct sock *xfrm_nl;
extern u32 sysctl_xfrm_aevent_etime;
extern u32 sysctl_xfrm_aevent_rseqth;

extern struct mutex xfrm_cfg_mutex;
# 94 "include/net/xfrm.h"
struct xfrm_state
{

 struct hlist_node bydst;
 struct hlist_node bysrc;
 struct hlist_node byspi;

 atomic_t refcnt;
 spinlock_t lock;

 struct xfrm_id id;
 struct xfrm_selector sel;

 u32 genid;


 struct {
  u8 state;
  u8 dying;
  u32 seq;
 } km;


 struct {
  u32 reqid;
  u8 mode;
  u8 replay_window;
  u8 aalgo, ealgo, calgo;
  u8 flags;
  u16 family;
  xfrm_address_t saddr;
  int header_len;
  int trailer_len;
 } props;

 struct xfrm_lifetime_cfg lft;


 struct xfrm_algo *aalg;
 struct xfrm_algo *ealg;
 struct xfrm_algo *calg;


 struct xfrm_encap_tmpl *encap;


 xfrm_address_t *coaddr;


 struct xfrm_state *tunnel;


 atomic_t tunnel_users;


 struct xfrm_replay_state replay;


 struct xfrm_replay_state preplay;




 u32 xflags;


 u32 replay_maxage;
 u32 replay_maxdiff;


 struct timer_list rtimer;


 struct xfrm_stats stats;

 struct xfrm_lifetime_cur curlft;
 struct timer_list timer;


 u64 lastused;



 struct xfrm_type *type;
 struct xfrm_mode *mode;


 struct xfrm_sec_ctx *security;



 void *data;
};




enum {
 XFRM_STATE_VOID,
 XFRM_STATE_ACQ,
 XFRM_STATE_VALID,
 XFRM_STATE_ERROR,
 XFRM_STATE_EXPIRED,
 XFRM_STATE_DEAD
};


struct km_event
{
 union {
  u32 hard;
  u32 proto;
  u32 byid;
  u32 aevent;
  u32 type;
 } data;

 u32 seq;
 u32 pid;
 u32 event;
};

struct xfrm_type;
struct xfrm_dst;
struct xfrm_policy_afinfo {
 unsigned short family;
 struct xfrm_type *type_map[IPPROTO_MAX];
 struct xfrm_mode *mode_map[5];
 struct dst_ops *dst_ops;
 void (*garbage_collect)(void);
 int (*dst_lookup)(struct xfrm_dst **dst, struct flowi *fl);
 int (*get_saddr)(xfrm_address_t *saddr, xfrm_address_t *daddr);
 struct dst_entry *(*find_bundle)(struct flowi *fl, struct xfrm_policy *policy);
 int (*bundle_create)(struct xfrm_policy *policy,
       struct xfrm_state **xfrm,
       int nx,
       struct flowi *fl,
       struct dst_entry **dst_p);
 void (*decode_session)(struct sk_buff *skb,
        struct flowi *fl);
};

extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
extern void km_state_notify(struct xfrm_state *x, struct km_event *c);


struct xfrm_tmpl;
extern int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
extern void km_state_expired(struct xfrm_state *x, int hard, u32 pid);
extern int __xfrm_state_delete(struct xfrm_state *x);

struct xfrm_state_afinfo {
 unsigned short family;
 int (*init_flags)(struct xfrm_state *x);
 void (*init_tempsel)(struct xfrm_state *x, struct flowi *fl,
      struct xfrm_tmpl *tmpl,
      xfrm_address_t *daddr, xfrm_address_t *saddr);
 int (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n);
 int (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);
};

extern int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
extern int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);

extern void xfrm_state_delete_tunnel(struct xfrm_state *x);

struct xfrm_type
{
 char *description;
 struct module *owner;
 __u8 proto;
 __u8 flags;


 int (*init_state)(struct xfrm_state *x);
 void (*destructor)(struct xfrm_state *);
 int (*input)(struct xfrm_state *, struct sk_buff *skb);
 int (*output)(struct xfrm_state *, struct sk_buff *pskb);
 int (*reject)(struct xfrm_state *, struct sk_buff *, struct flowi *);
 int (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
 xfrm_address_t *(*local_addr)(struct xfrm_state *, xfrm_address_t *);
 xfrm_address_t *(*remote_addr)(struct xfrm_state *, xfrm_address_t *);

 u32 (*get_max_size)(struct xfrm_state *, int size);
};

extern int xfrm_register_type(struct xfrm_type *type, unsigned short family);
extern int xfrm_unregister_type(struct xfrm_type *type, unsigned short family);
extern struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family);
extern void xfrm_put_type(struct xfrm_type *type);

struct xfrm_mode {
 int (*input)(struct xfrm_state *x, struct sk_buff *skb);
 int (*output)(struct xfrm_state *x,struct sk_buff *skb);

 struct module *owner;
 unsigned int encap;
};

extern int xfrm_register_mode(struct xfrm_mode *mode, int family);
extern int xfrm_unregister_mode(struct xfrm_mode *mode, int family);
extern struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family);
extern void xfrm_put_mode(struct xfrm_mode *mode);

struct xfrm_tmpl
{






 struct xfrm_id id;


 xfrm_address_t saddr;

 __u32 reqid;


 __u8 mode;


 __u8 share;


 __u8 optional;


 __u32 aalgos;
 __u32 ealgos;
 __u32 calgos;
};



struct xfrm_policy
{
 struct xfrm_policy *next;
 struct hlist_node bydst;
 struct hlist_node byidx;


 rwlock_t lock;
 atomic_t refcnt;
 struct timer_list timer;

 u8 type;
 u32 priority;
 u32 index;
 struct xfrm_selector selector;
 struct xfrm_lifetime_cfg lft;
 struct xfrm_lifetime_cur curlft;
 struct dst_entry *bundles;
 __u16 family;
 __u8 action;
 __u8 flags;
 __u8 dead;
 __u8 xfrm_nr;
 struct xfrm_sec_ctx *security;
 struct xfrm_tmpl xfrm_vec[6];
};
# 375 "include/net/xfrm.h"
struct xfrm_mgr
{
 struct list_head list;
 char *id;
 int (*notify)(struct xfrm_state *x, struct km_event *c);
 int (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
 struct xfrm_policy *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
 int (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
 int (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 int (*report)(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
};

extern int xfrm_register_km(struct xfrm_mgr *km);
extern int xfrm_unregister_km(struct xfrm_mgr *km);

extern unsigned int xfrm_policy_count[XFRM_POLICY_MAX*2];

static inline __attribute__((always_inline)) void xfrm_pol_hold(struct xfrm_policy *policy)
{
 if (__builtin_expect(!!(policy != ((void *)0)), 1))
  atomic_inc(&policy->refcnt);
}

extern void __xfrm_policy_destroy(struct xfrm_policy *policy);

static inline __attribute__((always_inline)) void xfrm_pol_put(struct xfrm_policy *policy)
{
 if ((atomic_sub_return(1, (&policy->refcnt)) == 0))
  __xfrm_policy_destroy(policy);
}
# 414 "include/net/xfrm.h"
static inline __attribute__((always_inline)) void xfrm_pols_put(struct xfrm_policy **pols, int npols)
{
 xfrm_pol_put(pols[0]);
}


extern void __xfrm_state_destroy(struct xfrm_state *);

static inline __attribute__((always_inline)) void __xfrm_state_put(struct xfrm_state *x)
{
 atomic_dec(&x->refcnt);
}

static inline __attribute__((always_inline)) void xfrm_state_put(struct xfrm_state *x)
{
 if ((atomic_sub_return(1, (&x->refcnt)) == 0))
  __xfrm_state_destroy(x);
}

static inline __attribute__((always_inline)) void xfrm_state_hold(struct xfrm_state *x)
{
 atomic_inc(&x->refcnt);
}

static __inline__ __attribute__((always_inline)) int addr_match(void *token1, void *token2, int prefixlen)
{
 __be32 *a1 = token1;
 __be32 *a2 = token2;
 int pdw;
 int pbi;

 pdw = prefixlen >> 5;
 pbi = prefixlen & 0x1f;

 if (pdw)
  if (memcmp(a1, a2, pdw << 2))
   return 0;

 if (pbi) {
  __be32 mask;

  mask = htonl((0xffffffff) << (32 - pbi));

  if ((a1[pdw] ^ a2[pdw]) & mask)
   return 0;
 }

 return 1;
}

static __inline__ __attribute__((always_inline))
__be16 xfrm_flowi_sport(struct flowi *fl)
{
 __be16 port;
 switch(fl->proto) {
 case IPPROTO_TCP:
 case IPPROTO_UDP:
 case IPPROTO_SCTP:
  port = fl->uli_u.ports.sport;
  break;
 case IPPROTO_ICMP:
 case 58:
  port = htons(fl->uli_u.icmpt.type);
  break;





 default:
  port = 0;
 }
 return port;
}

static __inline__ __attribute__((always_inline))
__be16 xfrm_flowi_dport(struct flowi *fl)
{
 __be16 port;
 switch(fl->proto) {
 case IPPROTO_TCP:
 case IPPROTO_UDP:
 case IPPROTO_SCTP:
  port = fl->uli_u.ports.dport;
  break;
 case IPPROTO_ICMP:
 case 58:
  port = htons(fl->uli_u.icmpt.code);
  break;
 default:
  port = 0;
 }
 return port;
}

static inline __attribute__((always_inline)) int
__xfrm4_selector_match(struct xfrm_selector *sel, struct flowi *fl)
{
 return addr_match(&fl->nl_u.ip4_u.daddr, &sel->daddr, sel->prefixlen_d) &&
  addr_match(&fl->nl_u.ip4_u.saddr, &sel->saddr, sel->prefixlen_s) &&
  !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
  !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
  (fl->proto == sel->proto || !sel->proto) &&
  (fl->oif == sel->ifindex || !sel->ifindex);
}

static inline __attribute__((always_inline)) int
__xfrm6_selector_match(struct xfrm_selector *sel, struct flowi *fl)
{
 return addr_match(&fl->nl_u.ip6_u.daddr, &sel->daddr, sel->prefixlen_d) &&
  addr_match(&fl->nl_u.ip6_u.saddr, &sel->saddr, sel->prefixlen_s) &&
  !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
  !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
  (fl->proto == sel->proto || !sel->proto) &&
  (fl->oif == sel->ifindex || !sel->ifindex);
}

static inline __attribute__((always_inline)) int
xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
      unsigned short family)
{
 switch (family) {
 case 2:
  return __xfrm4_selector_match(sel, fl);
 case 10:
  return __xfrm6_selector_match(sel, fl);
 }
 return 0;
}
# 557 "include/net/xfrm.h"
static inline __attribute__((always_inline)) int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
{
 return 1;
}
# 574 "include/net/xfrm.h"
struct xfrm_dst
{
 union {
  struct xfrm_dst *next;
  struct dst_entry dst;
  struct rtable rt;
  struct rt6_info rt6;
 } u;
 struct dst_entry *route;
 u32 genid;
 u32 route_mtu_cached;
 u32 child_mtu_cached;
 u32 route_cookie;
 u32 path_cookie;
};

static inline __attribute__((always_inline)) void xfrm_dst_destroy(struct xfrm_dst *xdst)
{
 dst_release(xdst->route);
 if (__builtin_expect(!!(xdst->u.dst.xfrm), 1))
  xfrm_state_put(xdst->u.dst.xfrm);
}

extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);

struct sec_path
{
 atomic_t refcnt;
 int len;
 struct xfrm_state *xvec[6];
};

static inline __attribute__((always_inline)) struct sec_path *
secpath_get(struct sec_path *sp)
{
 if (sp)
  atomic_inc(&sp->refcnt);
 return sp;
}

extern void __secpath_destroy(struct sec_path *sp);

static inline __attribute__((always_inline)) void
secpath_put(struct sec_path *sp)
{
 if (sp && (atomic_sub_return(1, (&sp->refcnt)) == 0))
  __secpath_destroy(sp);
}

extern struct sec_path *secpath_dup(struct sec_path *src);

static inline __attribute__((always_inline)) void
secpath_reset(struct sk_buff *skb)
{




}

static inline __attribute__((always_inline)) int
xfrm_addr_any(xfrm_address_t *addr, unsigned short family)
{
 switch (family) {
 case 2:
  return addr->a4 == 0;
 case 10:
  return ipv6_addr_any((struct in6_addr *)&addr->a6);
 }
 return 0;
}

static inline __attribute__((always_inline)) int
__xfrm4_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
{
 return (tmpl->saddr.a4 &&
   tmpl->saddr.a4 != x->props.saddr.a4);
}

static inline __attribute__((always_inline)) int
__xfrm6_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
{
 return (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
   ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
}

static inline __attribute__((always_inline)) int
xfrm_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x, unsigned short family)
{
 switch (family) {
 case 2:
  return __xfrm4_state_addr_cmp(tmpl, x);
 case 10:
  return __xfrm6_state_addr_cmp(tmpl, x);
 }
 return !0;
}
# 741 "include/net/xfrm.h"
static inline __attribute__((always_inline)) void xfrm_sk_free_policy(struct sock *sk) {}
static inline __attribute__((always_inline)) int xfrm_sk_clone_policy(struct sock *sk) { return 0; }
static inline __attribute__((always_inline)) int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
static inline __attribute__((always_inline)) int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
static inline __attribute__((always_inline)) int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
{
 return 1;
}
static inline __attribute__((always_inline)) int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
{
 return 1;
}
static inline __attribute__((always_inline)) int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
{
 return 1;
}


static __inline__ __attribute__((always_inline))
xfrm_address_t *xfrm_flowi_daddr(struct flowi *fl, unsigned short family)
{
 switch (family){
 case 2:
  return (xfrm_address_t *)&fl->nl_u.ip4_u.daddr;
 case 10:
  return (xfrm_address_t *)&fl->nl_u.ip6_u.daddr;
 }
 return ((void *)0);
}

static __inline__ __attribute__((always_inline))
xfrm_address_t *xfrm_flowi_saddr(struct flowi *fl, unsigned short family)
{
 switch (family){
 case 2:
  return (xfrm_address_t *)&fl->nl_u.ip4_u.saddr;
 case 10:
  return (xfrm_address_t *)&fl->nl_u.ip6_u.saddr;
 }
 return ((void *)0);
}

static __inline__ __attribute__((always_inline)) int
__xfrm4_state_addr_check(struct xfrm_state *x,
    xfrm_address_t *daddr, xfrm_address_t *saddr)
{
 if (daddr->a4 == x->id.daddr.a4 &&
     (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
  return 1;
 return 0;
}

static __inline__ __attribute__((always_inline)) int
__xfrm6_state_addr_check(struct xfrm_state *x,
    xfrm_address_t *daddr, xfrm_address_t *saddr)
{
 if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
     (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)||
      ipv6_addr_any((struct in6_addr *)saddr) ||
      ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
  return 1;
 return 0;
}

static __inline__ __attribute__((always_inline)) int
xfrm_state_addr_check(struct xfrm_state *x,
        xfrm_address_t *daddr, xfrm_address_t *saddr,
        unsigned short family)
{
 switch (family) {
 case 2:
  return __xfrm4_state_addr_check(x, daddr, saddr);
 case 10:
  return __xfrm6_state_addr_check(x, daddr, saddr);
 }
 return 0;
}

static __inline__ __attribute__((always_inline)) int
xfrm_state_addr_flow_check(struct xfrm_state *x, struct flowi *fl,
      unsigned short family)
{
 switch (family) {
 case 2:
  return __xfrm4_state_addr_check(x,
      (xfrm_address_t *)&fl->nl_u.ip4_u.daddr,
      (xfrm_address_t *)&fl->nl_u.ip4_u.saddr);
 case 10:
  return __xfrm6_state_addr_check(x,
      (xfrm_address_t *)&fl->nl_u.ip6_u.daddr,
      (xfrm_address_t *)&fl->nl_u.ip6_u.saddr);
 }
 return 0;
}

static inline __attribute__((always_inline)) int xfrm_state_kern(struct xfrm_state *x)
{
 return ((&x->tunnel_users)->counter);
}

static inline __attribute__((always_inline)) int xfrm_id_proto_match(u8 proto, u8 userproto)
{
 return (!userproto || proto == userproto ||
  (userproto == 255 && (proto == IPPROTO_AH ||
        proto == IPPROTO_ESP ||
        proto == IPPROTO_COMP)));
}




struct xfrm_algo_auth_info {
 u16 icv_truncbits;
 u16 icv_fullbits;
};

struct xfrm_algo_encr_info {
 u16 blockbits;
 u16 defkeybits;
};

struct xfrm_algo_comp_info {
 u16 threshold;
};

struct xfrm_algo_desc {
 char *name;
 char *compat;
 u8 available:1;
 union {
  struct xfrm_algo_auth_info auth;
  struct xfrm_algo_encr_info encr;
  struct xfrm_algo_comp_info comp;
 } uinfo;
 struct sadb_alg desc;
};


struct xfrm_tunnel {
 int (*handler)(struct sk_buff *skb);
 int (*err_handler)(struct sk_buff *skb, __u32 info);

 struct xfrm_tunnel *next;
 int priority;
};

struct xfrm6_tunnel {
 int (*handler)(struct sk_buff *skb);
 int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
      int type, int code, int offset, __u32 info);

 struct xfrm6_tunnel *next;
 int priority;
};

extern void xfrm_init(void);
extern void xfrm4_init(void);
extern void xfrm6_init(void);
extern void xfrm6_fini(void);
extern void xfrm_state_init(void);
extern void xfrm4_state_init(void);
extern void xfrm6_state_init(void);
extern void xfrm6_state_fini(void);

extern int xfrm_state_walk(u8 proto, int (*func)(struct xfrm_state *, int, void*), void *);
extern struct xfrm_state *xfrm_state_alloc(void);
extern struct xfrm_state *xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
       struct flowi *fl, struct xfrm_tmpl *tmpl,
       struct xfrm_policy *pol, int *err,
       unsigned short family);
extern int xfrm_state_check_expire(struct xfrm_state *x);
extern void xfrm_state_insert(struct xfrm_state *x);
extern int xfrm_state_add(struct xfrm_state *x);
extern int xfrm_state_update(struct xfrm_state *x);
extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family);
extern struct xfrm_state *xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);






static inline __attribute__((always_inline)) int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
     int n, unsigned short family)
{
 return -38;
}

static inline __attribute__((always_inline)) int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
      int n, unsigned short family)
{
 return -38;
}

extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
extern int xfrm_state_delete(struct xfrm_state *x);
extern void xfrm_state_flush(u8 proto);
extern int xfrm_replay_check(struct xfrm_state *x, __be32 seq);
extern void xfrm_replay_advance(struct xfrm_state *x, __be32 seq);
extern void xfrm_replay_notify(struct xfrm_state *x, int event);
extern int xfrm_state_check(struct xfrm_state *x, struct sk_buff *skb);
extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
extern int xfrm_init_state(struct xfrm_state *x);
extern int xfrm4_rcv(struct sk_buff *skb);
extern int xfrm4_output(struct sk_buff *skb);
extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler);
extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler);
extern int xfrm6_rcv_spi(struct sk_buff *skb, __be32 spi);
extern int xfrm6_rcv(struct sk_buff **pskb);
extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
       xfrm_address_t *saddr, u8 proto);
extern int xfrm6_tunnel_register(struct xfrm6_tunnel *handler);
extern int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler);
extern u32 xfrm6_tunnel_alloc_spi(xfrm_address_t *saddr);
extern void xfrm6_tunnel_free_spi(xfrm_address_t *saddr);
extern u32 xfrm6_tunnel_spi_lookup(xfrm_address_t *saddr);
extern int xfrm6_output(struct sk_buff *skb);
extern int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
     u8 **prevhdr);






static inline __attribute__((always_inline)) int xfrm_user_policy(struct sock *sk, int optname, u8 *optval, int optlen)
{
  return -92;
}

static inline __attribute__((always_inline)) int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type)
{

  kfree_skb(skb);
 return 0;
}
static inline __attribute__((always_inline)) int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family)
{
 return -22;
}


struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp);
extern int xfrm_policy_walk(u8 type, int (*func)(struct xfrm_policy *, int, int, void*), void *);
int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
struct xfrm_policy *xfrm_policy_bysel_ctx(u8 type, int dir,
       struct xfrm_selector *sel,
       struct xfrm_sec_ctx *ctx, int delete);
struct xfrm_policy *xfrm_policy_byid(u8, int dir, u32 id, int delete);
void xfrm_policy_flush(u8 type);
u32 xfrm_get_acqseq(void);
void xfrm_alloc_spi(struct xfrm_state *x, __be32 minspi, __be32 maxspi);
struct xfrm_state * xfrm_find_acq(u8 mode, u32 reqid, u8 proto,
      xfrm_address_t *daddr, xfrm_address_t *saddr,
      int create, unsigned short family);
extern void xfrm_policy_flush(u8 type);
extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
extern int xfrm_bundle_ok(struct xfrm_policy *pol, struct xfrm_dst *xdst,
     struct flowi *fl, int family, int strict);
extern void xfrm_init_pmtu(struct dst_entry *dst);

extern wait_queue_head_t km_waitq;
extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
extern int km_report(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);

extern void xfrm_input_init(void);
extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);

extern void xfrm_probe_algs(void);
extern int xfrm_count_auth_supported(void);
extern int xfrm_count_enc_supported(void);
extern struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
extern struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe);
extern struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe);
extern struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe);

struct hash_desc;
struct scatterlist;
typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
         unsigned int);

extern int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *tfm,
   int offset, int len, icv_update_fn_t icv_update);

static inline __attribute__((always_inline)) int xfrm_addr_cmp(xfrm_address_t *a, xfrm_address_t *b,
    int family)
{
 switch (family) {
 default:
 case 2:
  return a->a4 - b->a4;
 case 10:
  return ipv6_addr_cmp((struct in6_addr *)a,
         (struct in6_addr *)b);
 }
}

static inline __attribute__((always_inline)) int xfrm_policy_id2dir(u32 index)
{
 return index & 7;
}

static inline __attribute__((always_inline)) int xfrm_aevent_is_on(void)
{
 struct sock *nlsk;
 int ret = 0;

 do { do { } while (0); (void)0; } while(0);
 nlsk = ({ typeof(xfrm_nl) _________p1 = xfrm_nl; do { } while(0); (_________p1); });
 if (nlsk)
  ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
 do { (void)0; do { } while (0); } while(0);
 return ret;
}

static inline __attribute__((always_inline)) void xfrm_aevent_doreplay(struct xfrm_state *x)
{
 if (xfrm_aevent_is_on())
  xfrm_replay_notify(x, XFRM_AE_CR);
}
# 72 "net/ipv4/ip_output.c" 2


# 1 "include/net/arp.h" 1




# 1 "include/linux/if_arp.h" 1
# 103 "include/linux/if_arp.h"
struct arpreq {
  struct sockaddr arp_pa;
  struct sockaddr arp_ha;
  int arp_flags;
  struct sockaddr arp_netmask;
  char arp_dev[16];
};

struct arpreq_old {
  struct sockaddr arp_pa;
  struct sockaddr arp_ha;
  int arp_flags;
  struct sockaddr arp_netmask;
};
# 131 "include/linux/if_arp.h"
struct arphdr
{
 __be16 ar_hrd;
 __be16 ar_pro;
 unsigned char ar_hln;
 unsigned char ar_pln;
 __be16 ar_op;
# 149 "include/linux/if_arp.h"
};
# 6 "include/net/arp.h" 2




extern struct neigh_table arp_tbl;

extern void arp_init(void);
extern int arp_find(unsigned char *haddr, struct sk_buff *skb);
extern int arp_ioctl(unsigned int cmd, void *arg);
extern void arp_send(int type, int ptype, __be32 dest_ip,
    struct net_device *dev, __be32 src_ip,
    unsigned char *dest_hw, unsigned char *src_hw, unsigned char *th);
extern int arp_bind_neighbour(struct dst_entry *dst);
extern int arp_mc_map(u32 addr, u8 *haddr, struct net_device *dev, int dir);
extern void arp_ifdown(struct net_device *dev);

extern struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
      struct net_device *dev, __be32 src_ip,
      unsigned char *dest_hw, unsigned char *src_hw,
      unsigned char *target_hw);
extern void arp_xmit(struct sk_buff *skb);

extern struct neigh_ops arp_broken_ops;
# 75 "net/ipv4/ip_output.c" 2
# 1 "include/net/icmp.h" 1
# 21 "include/net/icmp.h"
# 1 "include/linux/icmp.h" 1
# 68 "include/linux/icmp.h"
struct icmphdr {
  __u8 type;
  __u8 code;
  __be16 checksum;
  union {
 struct {
  __be16 id;
  __be16 sequence;
 } echo;
 __be32 gateway;
 struct {
  __be16 __unused;
  __be16 mtu;
 } frag;
  } un;
};







struct icmp_filter {
 __u32 data;
};
# 22 "include/net/icmp.h" 2




struct icmp_err {
  int errno;
  unsigned fatal:1;
};

extern struct icmp_err icmp_err_convert[];
extern __typeof__(struct icmp_mib) *icmp_statistics[2];




struct dst_entry;
struct net_proto_family;
struct sk_buff;

extern void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info);
extern int icmp_rcv(struct sk_buff *skb);
extern int icmp_ioctl(struct sock *sk, int cmd, unsigned long arg);
extern void icmp_init(struct net_proto_family *ops);


extern int xrlim_allow(struct dst_entry *dst, int timeout);

struct raw_sock {

 struct inet_sock inet;
 struct icmp_filter filter;
};

static inline __attribute__((always_inline)) struct raw_sock *raw_sk(const struct sock *sk)
{
 return (struct raw_sock *)sk;
}

extern int sysctl_icmp_echo_ignore_all;
extern int sysctl_icmp_echo_ignore_broadcasts;
extern int sysctl_icmp_ignore_bogus_error_responses;
extern int sysctl_icmp_errors_use_inbound_ifaddr;
extern int sysctl_icmp_ratelimit;
extern int sysctl_icmp_ratemask;
# 76 "net/ipv4/ip_output.c" 2



# 1 "include/linux/igmp.h" 1
# 29 "include/linux/igmp.h"
struct igmphdr
{
 __u8 type;
 __u8 code;
 __be16 csum;
 __be32 group;
};
# 45 "include/linux/igmp.h"
struct igmpv3_grec {
 __u8 grec_type;
 __u8 grec_auxwords;
 __be16 grec_nsrcs;
 __be32 grec_mca;
 __be32 grec_src[0];
};

struct igmpv3_report {
 __u8 type;
 __u8 resv1;
 __be16 csum;
 __be16 resv2;
 __be16 ngrec;
 struct igmpv3_grec grec[0];
};

struct igmpv3_query {
 __u8 type;
 __u8 code;
 __be16 csum;
 __be32 group;

 __u8 qrv:3,
      suppress:1,
      resv:4;







 __u8 qqic;
 __be16 nsrcs;
 __be32 srcs[0];
};
# 132 "include/linux/igmp.h"
extern int sysctl_igmp_max_memberships;
extern int sysctl_igmp_max_msf;

struct ip_sf_socklist
{
 unsigned int sl_max;
 unsigned int sl_count;
 __be32 sl_addr[0];
};
# 151 "include/linux/igmp.h"
struct ip_mc_socklist
{
 struct ip_mc_socklist *next;
 struct ip_mreqn multi;
 unsigned int sfmode;
 struct ip_sf_socklist *sflist;
};

struct ip_sf_list
{
 struct ip_sf_list *sf_next;
 __be32 sf_inaddr;
 unsigned long sf_count[2];
 unsigned char sf_gsresp;
 unsigned char sf_oldin;
 unsigned char sf_crcount;
};

struct ip_mc_list
{
 struct in_device *interface;
 __be32 multiaddr;
 struct ip_sf_list *sources;
 struct ip_sf_list *tomb;
 unsigned int sfmode;
 unsigned long sfcount[2];
 struct ip_mc_list *next;
 struct timer_list timer;
 int users;
 atomic_t refcnt;
 spinlock_t lock;
 char tm_running;
 char reporter;
 char unsolicit_count;
 char loaded;
 unsigned char gsquery;
 unsigned char crcount;
};
# 200 "include/linux/igmp.h"
extern int ip_check_mc(struct in_device *dev, __be32 mc_addr, __be32 src_addr, u16 proto);
extern int igmp_rcv(struct sk_buff *);
extern int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr);
extern int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr);
extern void ip_mc_drop_socket(struct sock *sk);
extern int ip_mc_source(int add, int omode, struct sock *sk,
  struct ip_mreq_source *mreqs, int ifindex);
extern int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf,int ifindex);
extern int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
  struct ip_msfilter *optval, int *optlen);
extern int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
  struct group_filter *optval, int *optlen);
extern int ip_mc_sf_allow(struct sock *sk, __be32 local, __be32 rmt, int dif);
extern void ip_mr_init(void);
extern void ip_mc_init_dev(struct in_device *);
extern void ip_mc_destroy_dev(struct in_device *);
extern void ip_mc_up(struct in_device *);
extern void ip_mc_down(struct in_device *);
extern void ip_mc_dec_group(struct in_device *in_dev, __be32 addr);
extern void ip_mc_inc_group(struct in_device *in_dev, __be32 addr);
# 80 "net/ipv4/ip_output.c" 2
# 1 "include/linux/netfilter_ipv4.h" 1







# 1 "include/linux/netfilter.h" 1
# 350 "include/linux/netfilter.h"
static inline __attribute__((always_inline)) int nf_hook_thresh(int pf, unsigned int hook,
     struct sk_buff **pskb,
     struct net_device *indev,
     struct net_device *outdev,
     int (*okfn)(struct sk_buff *), int thresh,
     int cond)
{
 return okfn(*pskb);
}
static inline __attribute__((always_inline)) int nf_hook(int pf, unsigned int hook, struct sk_buff **pskb,
     struct net_device *indev, struct net_device *outdev,
     int (*okfn)(struct sk_buff *))
{
 return 1;
}
static inline __attribute__((always_inline)) void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
struct flowi;
static inline __attribute__((always_inline)) void
nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, int family) {}
# 9 "include/linux/netfilter_ipv4.h" 2
# 54 "include/linux/netfilter_ipv4.h"
enum nf_ip_hook_priorities {
 NF_IP_PRI_FIRST = (-((int)(~0U>>1)) - 1),
 NF_IP_PRI_CONNTRACK_DEFRAG = -400,
 NF_IP_PRI_RAW = -300,
 NF_IP_PRI_SELINUX_FIRST = -225,
 NF_IP_PRI_CONNTRACK = -200,
 NF_IP_PRI_BRIDGE_SABOTAGE_FORWARD = -175,
 NF_IP_PRI_MANGLE = -150,
 NF_IP_PRI_NAT_DST = -100,
 NF_IP_PRI_BRIDGE_SABOTAGE_LOCAL_OUT = -50,
 NF_IP_PRI_FILTER = 0,
 NF_IP_PRI_NAT_SRC = 100,
 NF_IP_PRI_SELINUX_LAST = 225,
 NF_IP_PRI_CONNTRACK_HELPER = ((int)(~0U>>1)) - 2,
 NF_IP_PRI_NAT_SEQ_ADJUST = ((int)(~0U>>1)) - 1,
 NF_IP_PRI_CONNTRACK_CONFIRM = ((int)(~0U>>1)),
 NF_IP_PRI_LAST = ((int)(~0U>>1)),
};
# 80 "include/linux/netfilter_ipv4.h"
extern int ip_route_me_harder(struct sk_buff **pskb, unsigned addr_type);
extern int ip_xfrm_me_harder(struct sk_buff **pskb);
extern unsigned int nf_ip_checksum(struct sk_buff *skb, unsigned int hook,
       unsigned int dataoff, u_int8_t protocol);
# 81 "net/ipv4/ip_output.c" 2
# 1 "include/linux/netfilter_bridge.h" 1
# 9 "include/linux/netfilter_bridge.h"
# 1 "include/linux/if_vlan.h" 1
# 19 "include/linux/if_vlan.h"
struct vlan_group;
struct net_device;
struct packet_type;
struct vlan_collection;
struct vlan_dev_info;
struct hlist_node;
# 42 "include/linux/if_vlan.h"
struct vlan_ethhdr {
   unsigned char h_dest[6];
   unsigned char h_source[6];
   __be16 h_vlan_proto;
   __be16 h_vlan_TCI;
   __be16 h_vlan_encapsulated_proto;
};



static inline __attribute__((always_inline)) struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
{
 return (struct vlan_ethhdr *)skb->mac.raw;
}

struct vlan_hdr {
   __be16 h_vlan_TCI;
   __be16 h_vlan_encapsulated_proto;
};




extern void vlan_ioctl_set(int (*hook)(void *));
# 75 "include/linux/if_vlan.h"
struct vlan_group {
 int real_dev_ifindex;
 struct hlist_node hlist;
 struct net_device *vlan_devices[4096];
 struct rcu_head rcu;
};

struct vlan_priority_tci_mapping {
 unsigned long priority;
 unsigned short vlan_qos;



 struct vlan_priority_tci_mapping *next;
};


struct vlan_dev_info {



 unsigned long ingress_priority_map[8];
 struct vlan_priority_tci_mapping *egress_priority_map[16];

 unsigned short vlan_id;
 unsigned short flags;







 struct dev_mc_list *old_mc_list;




 int old_allmulti;
 int old_promiscuity;
 struct net_device *real_dev;
 struct proc_dir_entry *dent;
 unsigned long cnt_inc_headroom_on_tx;
 unsigned long cnt_encap_on_xmit;
 struct net_device_stats dev_stats;
};





static inline __attribute__((always_inline)) struct net_device_stats *vlan_dev_get_stats(struct net_device *dev)
{
 return &(((struct vlan_dev_info *)(dev->priv))->dev_stats);
}

static inline __attribute__((always_inline)) __u32 vlan_get_ingress_priority(struct net_device *dev,
           unsigned short vlan_tag)
{
 struct vlan_dev_info *vip = ((struct vlan_dev_info *)(dev->priv));

 return vip->ingress_priority_map[(vlan_tag >> 13) & 0x7];
}


struct vlan_skb_tx_cookie {
 u32 magic;
 u32 vlan_tag;
};
# 152 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) int __vlan_hwaccel_rx(struct sk_buff *skb,
        struct vlan_group *grp,
        unsigned short vlan_tag, int polling)
{
 struct net_device_stats *stats;

 if (skb_bond_should_drop(skb)) {
  dev_kfree_skb_any(skb);
  return 1;
 }

 skb->dev = grp->vlan_devices[vlan_tag & 0xfff];
 if (skb->dev == ((void *)0)) {
  dev_kfree_skb_any(skb);




  return 0;
 }

 skb->dev->last_rx = jiffies;

 stats = vlan_dev_get_stats(skb->dev);
 stats->rx_packets++;
 stats->rx_bytes += skb->len;

 skb->priority = vlan_get_ingress_priority(skb->dev, vlan_tag);
 switch (skb->pkt_type) {
 case 1:
  break;

 case 2:
  stats->multicast++;
  break;

 case 3:




  if (!compare_ether_addr(eth_hdr(skb)->h_dest,
            skb->dev->dev_addr))
   skb->pkt_type = 0;
  break;
 };

 return (polling ? netif_receive_skb(skb) : netif_rx(skb));
}

static inline __attribute__((always_inline)) int vlan_hwaccel_rx(struct sk_buff *skb,
      struct vlan_group *grp,
      unsigned short vlan_tag)
{
 return __vlan_hwaccel_rx(skb, grp, vlan_tag, 0);
}

static inline __attribute__((always_inline)) int vlan_hwaccel_receive_skb(struct sk_buff *skb,
        struct vlan_group *grp,
        unsigned short vlan_tag)
{
 return __vlan_hwaccel_rx(skb, grp, vlan_tag, 1);
}
# 227 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) struct sk_buff *__vlan_put_tag(struct sk_buff *skb, unsigned short tag)
{
 struct vlan_ethhdr *veth;

 if (skb_headroom(skb) < 4) {
  struct sk_buff *sk_tmp = skb;
  skb = skb_realloc_headroom(sk_tmp, 4);
  kfree_skb(sk_tmp);
  if (!skb) {
   printk("<3>" "vlan: failed to realloc headroom\n");
   return ((void *)0);
  }
 } else {
  skb = skb_unshare(skb, ((( gfp_t)0x20u)));
  if (!skb) {
   printk("<3>" "vlan: failed to unshare skbuff\n");
   return ((void *)0);
  }
 }

 veth = (struct vlan_ethhdr *)skb_push(skb, 4);


 memmove(skb->data, skb->data + 4, 2 * 6);


 veth->h_vlan_proto = (( __be16)((__u16)( (((__u16)((0x8100)) & (__u16)0x00ffU) << 8) | (((__u16)((0x8100)) & (__u16)0xff00U) >> 8) )));


 veth->h_vlan_TCI = htons(tag);

 skb->protocol = (( __be16)((__u16)( (((__u16)((0x8100)) & (__u16)0x00ffU) << 8) | (((__u16)((0x8100)) & (__u16)0xff00U) >> 8) )));
 skb->mac.raw -= 4;
 skb->nh.raw -= 4;

 return skb;
}
# 272 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, unsigned short tag)
{
 struct vlan_skb_tx_cookie *cookie;

 cookie = ((struct vlan_skb_tx_cookie *)&((skb)->cb[0]));
 cookie->magic = 0x564c414e;
 cookie->vlan_tag = tag;

 return skb;
}
# 293 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) struct sk_buff *vlan_put_tag(struct sk_buff *skb, unsigned short tag)
{
 if (skb->dev->features & 128) {
  return __vlan_hwaccel_put_tag(skb, tag);
 } else {
  return __vlan_put_tag(skb, tag);
 }
}
# 309 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) int __vlan_get_tag(struct sk_buff *skb, unsigned short *tag)
{
 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;

 if (veth->h_vlan_proto != (( __be16)((__u16)( (((__u16)((0x8100)) & (__u16)0x00ffU) << 8) | (((__u16)((0x8100)) & (__u16)0xff00U) >> 8) )))) {
  return -22;
 }

 *tag = ntohs(veth->h_vlan_TCI);

 return 0;
}
# 329 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) int __vlan_hwaccel_get_tag(struct sk_buff *skb, unsigned short *tag)
{
 struct vlan_skb_tx_cookie *cookie;

 cookie = ((struct vlan_skb_tx_cookie *)&((skb)->cb[0]));
 if (cookie->magic == 0x564c414e) {
  *tag = cookie->vlan_tag;
  return 0;
 } else {
  *tag = 0;
  return -22;
 }
}
# 352 "include/linux/if_vlan.h"
static inline __attribute__((always_inline)) int vlan_get_tag(struct sk_buff *skb, unsigned short *tag)
{
 if (skb->dev->features & 128) {
  return __vlan_hwaccel_get_tag(skb, tag);
 } else {
  return __vlan_get_tag(skb, tag);
 }
}






enum vlan_ioctl_cmds {
 ADD_VLAN_CMD,
 DEL_VLAN_CMD,
 SET_VLAN_INGRESS_PRIORITY_CMD,
 SET_VLAN_EGRESS_PRIORITY_CMD,
 GET_VLAN_INGRESS_PRIORITY_CMD,
 GET_VLAN_EGRESS_PRIORITY_CMD,
 SET_VLAN_NAME_TYPE_CMD,
 SET_VLAN_FLAG_CMD,
 GET_VLAN_REALDEV_NAME_CMD,
 GET_VLAN_VID_CMD
};

enum vlan_name_types {
 VLAN_NAME_TYPE_PLUS_VID,
 VLAN_NAME_TYPE_RAW_PLUS_VID,
 VLAN_NAME_TYPE_PLUS_VID_NO_PAD,
 VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD,
 VLAN_NAME_TYPE_HIGHEST
};

struct vlan_ioctl_args {
 int cmd;
 char device1[24];

        union {
  char device2[24];
  int VID;
  unsigned int skb_priority;
  unsigned int name_type;
  unsigned int bind_type;
  unsigned int flag;
        } u;

 short vlan_qos;
};
# 10 "include/linux/netfilter_bridge.h" 2
# 28 "include/linux/netfilter_bridge.h"
enum nf_br_hook_priorities {
 NF_BR_PRI_FIRST = (-((int)(~0U>>1)) - 1),
 NF_BR_PRI_NAT_DST_BRIDGED = -300,
 NF_BR_PRI_FILTER_BRIDGED = -200,
 NF_BR_PRI_BRNF = 0,
 NF_BR_PRI_NAT_DST_OTHER = 100,
 NF_BR_PRI_FILTER_OTHER = 200,
 NF_BR_PRI_NAT_SRC = 300,
 NF_BR_PRI_LAST = ((int)(~0U>>1)),
};
# 82 "net/ipv4/ip_output.c" 2
# 1 "include/linux/mroute.h" 1
# 34 "include/linux/mroute.h"
typedef unsigned long vifbitmap_t;
typedef unsigned short vifi_t;
# 54 "include/linux/mroute.h"
struct vifctl {
 vifi_t vifc_vifi;
 unsigned char vifc_flags;
 unsigned char vifc_threshold;
 unsigned int vifc_rate_limit;
 struct in_addr vifc_lcl_addr;
 struct in_addr vifc_rmt_addr;
};
# 71 "include/linux/mroute.h"
struct mfcctl
{
 struct in_addr mfcc_origin;
 struct in_addr mfcc_mcastgrp;
 vifi_t mfcc_parent;
 unsigned char mfcc_ttls[32];
 unsigned int mfcc_pkt_cnt;
 unsigned int mfcc_byte_cnt;
 unsigned int mfcc_wrong_if;
 int mfcc_expire;
};





struct sioc_sg_req
{
 struct in_addr src;
 struct in_addr grp;
 unsigned long pktcnt;
 unsigned long bytecnt;
 unsigned long wrong_if;
};





struct sioc_vif_req
{
 vifi_t vifi;
 unsigned long icount;
 unsigned long ocount;
 unsigned long ibytes;
 unsigned long obytes;
};






struct igmpmsg
{
 __u32 unused1,unused2;
 unsigned char im_msgtype;
 unsigned char im_mbz;
 unsigned char im_vif;
 unsigned char unused3;
 struct in_addr im_src,im_dst;
};
# 131 "include/linux/mroute.h"
extern int ip_mroute_setsockopt(struct sock *, int, char *, int);
extern int ip_mroute_getsockopt(struct sock *, int, char *, int *);
extern int ipmr_ioctl(struct sock *sk, int cmd, void *arg);
extern void ip_mr_init(void);


struct vif_device
{
 struct net_device *dev;
 unsigned long bytes_in,bytes_out;
 unsigned long pkt_in,pkt_out;
 unsigned long rate_limit;
 unsigned char threshold;
 unsigned short flags;
 __be32 local,remote;
 int link;
};



struct mfc_cache
{
 struct mfc_cache *next;
 __be32 mfc_mcastgrp;
 __be32 mfc_origin;
 vifi_t mfc_parent;
 int mfc_flags;

 union {
  struct {
   unsigned long expires;
   struct sk_buff_head unresolved;
  } unres;
  struct {
   unsigned long last_assert;
   int minvif;
   int maxvif;
   unsigned long bytes;
   unsigned long pkt;
   unsigned long wrong_if;
   unsigned char ttls[32];
  } res;
 } mfc_un;
};
# 212 "include/linux/mroute.h"
struct pimreghdr
{
 __u8 type;
 __u8 reserved;
 __be16 csum;
 __be32 flags;
};

extern int pim_rcv_v1(struct sk_buff *);

struct rtmsg;
extern int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait);
# 83 "net/ipv4/ip_output.c" 2



int sysctl_ip_default_ttl = 64;



void ip_send_check(struct iphdr *iph)
{
 iph->check = 0;
 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
}


static int ip_dev_loopback_xmit(struct sk_buff *newskb)
{
 newskb->mac.raw = newskb->data;
 __skb_pull(newskb, newskb->nh.raw - newskb->data);
 newskb->pkt_type = 5;
 newskb->ip_summed = 2;
 do { if (__builtin_expect(!!(!(newskb->dst)), 0)) { printk("<3>" "KERNEL: assertion (%s) failed at %s (%d)\n", "newskb->dst", "net/ipv4/ip_output.c" , 103); } } while(0);
 netif_rx(newskb);
 return 0;
}

static inline __attribute__((always_inline)) int ip_select_ttl(struct inet_sock *inet, struct dst_entry *dst)
{
 int ttl = inet->uc_ttl;

 if (ttl < 0)
  ttl = dst_metric(dst, RTAX_HOPLIMIT);
 return ttl;
}





int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
     __be32 saddr, __be32 daddr, struct ip_options *opt)
{
 struct inet_sock *inet = inet_sk(sk);
 struct rtable *rt = (struct rtable *)skb->dst;
 struct iphdr *iph;


 if (opt)
  iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr) + opt->optlen);
 else
  iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr));

 iph->version = 4;
 iph->ihl = 5;
 iph->tos = inet->tos;
 if (ip_dont_fragment(sk, &rt->u.dst))
  iph->frag_off = htons(0x4000);
 else
  iph->frag_off = 0;
 iph->ttl = ip_select_ttl(inet, &rt->u.dst);
 iph->daddr = rt->rt_dst;
 iph->saddr = rt->rt_src;
 iph->protocol = sk->sk_protocol;
 iph->tot_len = htons(skb->len);
 ip_select_ident(iph, &rt->u.dst, sk);
 skb->nh.iph = iph;

 if (opt && opt->optlen) {
  iph->ihl += opt->optlen>>2;
  ip_options_build(skb, opt, daddr, rt, 0);
 }
 ip_send_check(iph);

 skb->priority = sk->sk_priority;


 return (dst_output)(skb);

}

extern typeof(ip_build_and_send_pkt) ip_build_and_send_pkt; static const char __kstrtab_ip_build_and_send_pkt[] __attribute__((section("__ksymtab_strings"))) = "_" "ip_build_and_send_pkt"; static const struct kernel_symbol __ksymtab_ip_build_and_send_pkt __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&ip_build_and_send_pkt, __kstrtab_ip_build_and_send_pkt };

static inline __attribute__((always_inline)) int ip_finish_output2(struct sk_buff *skb)
{
 struct dst_entry *dst = skb->dst;
 struct hh_cache *hh = dst->hh;
 struct net_device *dev = dst->dev;
 int hh_len = (((dev)->hard_header_len&~(16 - 1)) + 16);


 if (__builtin_expect(!!(skb_headroom(skb) < hh_len && dev->hard_header), 0)) {
  struct sk_buff *skb2;

  skb2 = skb_realloc_headroom(skb, (((dev)->hard_header_len&~(16 - 1)) + 16));
  if (skb2 == ((void *)0)) {
   kfree_skb(skb);
   return -12;
  }
  if (skb->sk)
   skb_set_owner_w(skb2, skb->sk);
  kfree_skb(skb);
  skb = skb2;
 }

 if (hh) {
  int hh_alen;

  do { local_bh_disable(); do { do { } while (0); (void)0; (void)(&hh->hh_lock); } while (0); } while (0);
  hh_alen = (((hh->hh_len)+(16 -1))&~(16 - 1));
    memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
  do { do { } while (0); local_bh_enable(); (void)0; (void)(&hh->hh_lock); } while (0);
         skb_push(skb, hh->hh_len);
  return hh->hh_output(skb);
 } else if (dst->neighbour)
  return dst->neighbour->output(skb);

 if (net_ratelimit())
  printk("<7>" "ip_finish_output2: No header cache and no neighbour!\n");
 kfree_skb(skb);
 return -22;
}

static inline __attribute__((always_inline)) int ip_finish_output(struct sk_buff *skb)
{







 if (skb->len > dst_mtu(skb->dst) && !skb_is_gso(skb))
  return ip_fragment(skb, ip_finish_output2);
 else
  return ip_finish_output2(skb);
}

int ip_mc_output(struct sk_buff *skb)
{
 struct sock *sk = skb->sk;
 struct rtable *rt = (struct rtable*)skb->dst;
 struct net_device *dev = rt->u.dst.dev;




 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_OUTREQUESTS]++);

 skb->dev = dev;
 skb->protocol = htons(0x0800);





 if (rt->rt_flags&0x20000000) {
  if ((!sk || inet_sk(sk)->mc_loop)
# 250 "net/ipv4/ip_output.c"
  ) {
   struct sk_buff *newskb = skb_clone(skb, ((( gfp_t)0x20u)));
   if (newskb)
    (ip_dev_loopback_xmit)(newskb);


  }



  if (skb->nh.iph->ttl == 0) {
   kfree_skb(skb);
   return 0;
  }
 }

 if (rt->rt_flags&0x10000000) {
  struct sk_buff *newskb = skb_clone(skb, ((( gfp_t)0x20u)));
  if (newskb)
   (ip_dev_loopback_xmit)(newskb);

 }

 return (ip_finish_output)(skb);


}

int ip_output(struct sk_buff *skb)
{
 struct net_device *dev = skb->dst->dev;

 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_OUTREQUESTS]++);

 skb->dev = dev;
 skb->protocol = htons(0x0800);

 return (ip_finish_output)(skb);


}

int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
{
 struct sock *sk = skb->sk;
 struct inet_sock *inet = inet_sk(sk);
 struct ip_options *opt = inet->opt;
 struct rtable *rt;
 struct iphdr *iph;




 rt = (struct rtable *) skb->dst;
 if (rt != ((void *)0))
  goto packet_routed;


 rt = (struct rtable *)__sk_dst_check(sk, 0);
 if (rt == ((void *)0)) {
  __be32 daddr;


  daddr = inet->daddr;
  if(opt && opt->srr)
   daddr = opt->faddr;

  {
   struct flowi fl = { .oif = sk->__sk_common.skc_bound_dev_if,
         .nl_u = { .ip4_u =
            { .daddr = daddr,
       .saddr = inet->saddr,
       .tos = (((inet_sk(sk)->tos)&0x1E) | sock_flag(sk, SOCK_LOCALROUTE)) } },
         .proto = sk->sk_protocol,
         .uli_u = { .ports =
             { .sport = inet->sport,
        .dport = inet->dport } } };





   security_sk_classify_flow(sk, &fl);
   if (ip_route_output_flow(&rt, &fl, sk, 0))
    goto no_route;
  }
  sk_setup_caps(sk, &rt->u.dst);
 }
 skb->dst = dst_clone(&rt->u.dst);

packet_routed:
 if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
  goto no_route;


 iph = (struct iphdr *) skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0));
 *((__u16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));
 iph->tot_len = htons(skb->len);
 if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok)
  iph->frag_off = htons(0x4000);
 else
  iph->frag_off = 0;
 iph->ttl = ip_select_ttl(inet, &rt->u.dst);
 iph->protocol = sk->sk_protocol;
 iph->saddr = rt->rt_src;
 iph->daddr = rt->rt_dst;
 skb->nh.iph = iph;


 if (opt && opt->optlen) {
  iph->ihl += opt->optlen >> 2;
  ip_options_build(skb, opt, inet->daddr, rt, 0);
 }

 ip_select_ident_more(iph, &rt->u.dst, sk,
        (((struct skb_shared_info *)((skb)->end))->gso_segs ?: 1) - 1);


 ip_send_check(iph);

 skb->priority = sk->sk_priority;

 return (dst_output)(skb);


no_route:
 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_OUTNOROUTES]++);
 kfree_skb(skb);
 return -113;
}


static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)
{
 to->pkt_type = from->pkt_type;
 to->priority = from->priority;
 to->protocol = from->protocol;
 dst_release(to->dst);
 to->dst = dst_clone(from->dst);
 to->dev = from->dev;


 ((struct inet_skb_parm*)((to)->cb))->flags = ((struct inet_skb_parm*)((from)->cb))->flags;
# 413 "net/ipv4/ip_output.c"
 skb_copy_secmark(to, from);
}
# 423 "net/ipv4/ip_output.c"
int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*))
{
 struct iphdr *iph;
 int raw = 0;
 int ptr;
 struct net_device *dev;
 struct sk_buff *skb2;
 unsigned int mtu, hlen, left, len, ll_rs, pad;
 int offset;
 __be16 not_last_frag;
 struct rtable *rt = (struct rtable*)skb->dst;
 int err = 0;

 dev = rt->u.dst.dev;





 iph = skb->nh.iph;

 if (__builtin_expect(!!((iph->frag_off & htons(0x4000)) && !skb->local_df), 0)) {
  (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGFAILS]++);
  icmp_send(skb, 3, 4,
     htonl(dst_mtu(&rt->u.dst)));
  kfree_skb(skb);
  return -90;
 }





 hlen = iph->ihl * 4;
 mtu = dst_mtu(&rt->u.dst) - hlen;
 ((struct inet_skb_parm*)((skb)->cb))->flags |= 8;
# 467 "net/ipv4/ip_output.c"
 if (((struct skb_shared_info *)((skb)->end))->frag_list) {
  struct sk_buff *frag;
  int first_len = skb_pagelen(skb);

  if (first_len - hlen > mtu ||
      ((first_len - hlen) & 7) ||
      (iph->frag_off & htons(0x2000|0x1FFF)) ||
      skb_cloned(skb))
   goto slow_path;

  for (frag = ((struct skb_shared_info *)((skb)->end))->frag_list; frag; frag = frag->next) {

   if (frag->len > mtu ||
       ((frag->len & 7) && frag->next) ||
       skb_headroom(frag) < hlen)
       goto slow_path;


   if (skb_shared(frag))
    goto slow_path;

   do { if (__builtin_expect(!!((frag->sk)!=0), 0)) do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "net/ipv4/ip_output.c", 488); panic("BUG!"); } while (0); } while(0);
   if (skb->sk) {
    sock_hold(skb->sk);
    frag->sk = skb->sk;
    frag->destructor = sock_wfree;
    skb->truesize -= frag->truesize;
   }
  }



  err = 0;
  offset = 0;
  frag = ((struct skb_shared_info *)((skb)->end))->frag_list;
  ((struct skb_shared_info *)((skb)->end))->frag_list = ((void *)0);
  skb->data_len = first_len - skb_headlen(skb);
  skb->len = first_len;
  iph->tot_len = htons(first_len);
  iph->frag_off = htons(0x2000);
  ip_send_check(iph);

  for (;;) {


   if (frag) {
    frag->ip_summed = 0;
    frag->h.raw = frag->data;
    frag->nh.raw = __skb_push(frag, hlen);
    memcpy(frag->nh.raw, iph, hlen);
    iph = frag->nh.iph;
    iph->tot_len = htons(frag->len);
    ip_copy_metadata(frag, skb);
    if (offset == 0)
     ip_options_fragment(frag);
    offset += skb->len - hlen;
    iph->frag_off = htons(offset>>3);
    if (frag->next != ((void *)0))
     iph->frag_off |= htons(0x2000);

    ip_send_check(iph);
   }

   err = output(skb);

   if (!err)
    (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGCREATES]++);
   if (err || !frag)
    break;

   skb = frag;
   frag = skb->next;
   skb->next = ((void *)0);
  }

  if (err == 0) {
   (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGOKS]++);
   return 0;
  }

  while (frag) {
   skb = frag->next;
   kfree_skb(frag);
   frag = skb;
  }
  (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGFAILS]++);
  return err;
 }

slow_path:
 left = skb->len - hlen;
 ptr = raw + hlen;




 pad = (0);
 ll_rs = ((((rt->u.dst.dev)->hard_header_len+pad)&~(16 - 1)) + 16);
 mtu -= pad;





 offset = (ntohs(iph->frag_off) & 0x1FFF) << 3;
 not_last_frag = iph->frag_off & htons(0x2000);





 while(left > 0) {
  len = left;

  if (len > mtu)
   len = mtu;


  if (len < left) {
   len &= ~7;
  }




  if ((skb2 = alloc_skb(len+hlen+ll_rs, ((( gfp_t)0x20u)))) == ((void *)0)) {
   do { } while (0);
   err = -12;
   goto fail;
  }





  ip_copy_metadata(skb2, skb);
  skb_reserve(skb2, ll_rs);
  skb_put(skb2, len + hlen);
  skb2->nh.raw = skb2->data;
  skb2->h.raw = skb2->data + hlen;






  if (skb->sk)
   skb_set_owner_w(skb2, skb->sk);





  memcpy(skb2->nh.raw, skb->data, hlen);




  if (skb_copy_bits(skb, ptr, skb2->h.raw, len))
   do { dump_stack(); printk("<4>" "\nkernel BUG at %s:%d!\n", "net/ipv4/ip_output.c", 626); panic("BUG!"); } while (0);
  left -= len;




  iph = skb2->nh.iph;
  iph->frag_off = htons((offset >> 3));







  if (offset == 0)
   ip_options_fragment(skb);





  if (left > 0 || not_last_frag)
   iph->frag_off |= htons(0x2000);
  ptr += len;
  offset += len;




  iph->tot_len = htons(len + hlen);

  ip_send_check(iph);

  err = output(skb2);
  if (err)
   goto fail;

  (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGCREATES]++);
 }
 kfree_skb(skb);
 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGOKS]++);
 return err;

fail:
 kfree_skb(skb);
 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_FRAGFAILS]++);
 return err;
}

extern typeof(ip_fragment) ip_fragment; static const char __kstrtab_ip_fragment[] __attribute__((section("__ksymtab_strings"))) = "_" "ip_fragment"; static const struct kernel_symbol __ksymtab_ip_fragment __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&ip_fragment, __kstrtab_ip_fragment };

int
ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
{
 struct iovec *iov = from;

 if (skb->ip_summed == 1) {
  if (memcpy_fromiovecend(to, iov, offset, len) < 0)
   return -14;
 } else {
  unsigned int csum = 0;
  if (csum_partial_copy_fromiovecend(to, iov, offset, len, &csum) < 0)
   return -14;
  skb->csum = csum_block_add(skb->csum, csum, odd);
 }
 return 0;
}

static inline __attribute__((always_inline)) unsigned int
csum_page(struct page *page, int offset, int copy)
{
 char *kaddr;
 unsigned int csum;
 kaddr = kmap(page);
 csum = csum_partial(kaddr + offset, copy, 0);
 do { (void) (page); } while (0);
 return csum;
}

static inline __attribute__((always_inline)) int ip_ufo_append_data(struct sock *sk,
   int getfrag(void *from, char *to, int offset, int len,
          int odd, struct sk_buff *skb),
   void *from, int length, int hh_len, int fragheaderlen,
   int transhdrlen, int mtu,unsigned int flags)
{
 struct sk_buff *skb;
 int err;





 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == ((void *)0)) {
  skb = sock_alloc_send_skb(sk,
   hh_len + fragheaderlen + transhdrlen + 20,
   (flags & 0x40), &err);

  if (skb == ((void *)0))
   return err;


  skb_reserve(skb, hh_len);


  skb_put(skb,fragheaderlen + transhdrlen);


  skb->nh.raw = skb->data;


  skb->h.raw = skb->data + fragheaderlen;

  skb->ip_summed = 1;
  skb->csum = 0;
  sk->sk_sndmsg_off = 0;
 }

 err = skb_append_datato_frags(sk,skb, getfrag, from,
          (length - transhdrlen));
 if (!err) {

  ((struct skb_shared_info *)((skb)->end))->gso_size = mtu - fragheaderlen;
  ((struct skb_shared_info *)((skb)->end))->gso_type = SKB_GSO_UDP;
  __skb_queue_tail(&sk->sk_write_queue, skb);

  return 0;
 }



 kfree_skb(skb);
 return err;
}
# 772 "net/ipv4/ip_output.c"
int ip_append_data(struct sock *sk,
     int getfrag(void *from, char *to, int offset, int len,
          int odd, struct sk_buff *skb),
     void *from, int length, int transhdrlen,
     struct ipcm_cookie *ipc, struct rtable *rt,
     unsigned int flags)
{
 struct inet_sock *inet = inet_sk(sk);
 struct sk_buff *skb;

 struct ip_options *opt = ((void *)0);
 int hh_len;
 int exthdrlen;
 int mtu;
 int copy;
 int err;
 int offset = 0;
 unsigned int maxfraglen, fragheaderlen;
 int csummode = 0;

 if (flags&0x10)
  return 0;

 if (skb_queue_empty(&sk->sk_write_queue)) {



  opt = ipc->opt;
  if (opt) {
   if (inet->cork.opt == ((void *)0)) {
    inet->cork.opt = kmalloc(sizeof(struct ip_options) + 40, sk->sk_allocation);
    if (__builtin_expect(!!(inet->cork.opt == ((void *)0)), 0))
     return -105;
   }
   memcpy(inet->cork.opt, opt, sizeof(struct ip_options)+opt->optlen);
   inet->cork.flags |= 1;
   inet->cork.addr = ipc->addr;
  }
  dst_hold(&rt->u.dst);
  inet->cork.fragsize = mtu = dst_mtu(rt->u.dst.path);
  inet->cork.rt = rt;
  inet->cork.length = 0;
  sk->sk_sndmsg_page = ((void *)0);
  sk->sk_sndmsg_off = 0;
  if ((exthdrlen = rt->u.dst.header_len) != 0) {
   length += exthdrlen;
   transhdrlen += exthdrlen;
  }
 } else {
  rt = inet->cork.rt;
  if (inet->cork.flags & 1)
   opt = inet->cork.opt;

  transhdrlen = 0;
  exthdrlen = 0;
  mtu = inet->cork.fragsize;
 }
 hh_len = (((rt->u.dst.dev)->hard_header_len&~(16 - 1)) + 16);

 fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;

 if (inet->cork.length + length > 0xFFFF - fragheaderlen) {
  ip_local_error(sk, 90, rt->rt_dst, inet->dport, mtu-exthdrlen);
  return -90;
 }





 if (transhdrlen &&
     length + fragheaderlen <= mtu &&
     rt->u.dst.dev->features & (2 | (4 | 8)) &&
     !exthdrlen)
  csummode = 1;

 inet->cork.length += length;
 if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) &&
   (rt->u.dst.dev->features & (SKB_GSO_UDP << 16))) {

  err = ip_ufo_append_data(sk, getfrag, from, length, hh_len,
      fragheaderlen, transhdrlen, mtu,
      flags);
  if (err)
   goto error;
  return 0;
 }
# 868 "net/ipv4/ip_output.c"
 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == ((void *)0))
  goto alloc_new_skb;

 while (length > 0) {

  copy = mtu - skb->len;
  if (copy < length)
   copy = maxfraglen - skb->len;
  if (copy <= 0) {
   char *data;
   unsigned int datalen;
   unsigned int fraglen;
   unsigned int fraggap;
   unsigned int alloclen;
   struct sk_buff *skb_prev;
alloc_new_skb:
   skb_prev = skb;
   if (skb_prev)
    fraggap = skb_prev->len - maxfraglen;
   else
    fraggap = 0;





   datalen = length + fraggap;
   if (datalen > mtu - fragheaderlen)
    datalen = maxfraglen - fragheaderlen;
   fraglen = datalen + fragheaderlen;

   if ((flags & 0x8000) &&
       !(rt->u.dst.dev->features&1))
    alloclen = mtu;
   else
    alloclen = datalen + fragheaderlen;






   if (datalen == length + fraggap)
    alloclen += rt->u.dst.trailer_len;

   if (transhdrlen) {
    skb = sock_alloc_send_skb(sk,
      alloclen + hh_len + 15,
      (flags & 0x40), &err);
   } else {
    skb = ((void *)0);
    if (((&sk->sk_wmem_alloc)->counter) <=
        2 * sk->sk_sndbuf)
     skb = sock_wmalloc(sk,
          alloclen + hh_len + 15, 1,
          sk->sk_allocation);
    if (__builtin_expect(!!(skb == ((void *)0)), 0))
     err = -105;
   }
   if (skb == ((void *)0))
    goto error;




   skb->ip_summed = csummode;
   skb->csum = 0;
   skb_reserve(skb, hh_len);




   data = skb_put(skb, fraglen);
   skb->nh.raw = data + exthdrlen;
   data += fragheaderlen;
   skb->h.raw = data + exthdrlen;

   if (fraggap) {
    skb->csum = skb_copy_and_csum_bits(
     skb_prev, maxfraglen,
     data + transhdrlen, fraggap, 0);
    skb_prev->csum = csum_sub(skb_prev->csum,
         skb->csum);
    data += fraggap;
    pskb_trim_unique(skb_prev, maxfraglen);
   }

   copy = datalen - transhdrlen - fraggap;
   if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
    err = -14;
    kfree_skb(skb);
    goto error;
   }

   offset += copy;
   length -= datalen - fraggap;
   transhdrlen = 0;
   exthdrlen = 0;
   csummode = 0;




   __skb_queue_tail(&sk->sk_write_queue, skb);
   continue;
  }

  if (copy > length)
   copy = length;

  if (!(rt->u.dst.dev->features&1)) {
   unsigned int off;

   off = skb->len;
   if (getfrag(from, skb_put(skb, copy),
     offset, copy, off, skb) < 0) {
    __skb_trim(skb, off);
    err = -14;
    goto error;
   }
  } else {
   int i = ((struct skb_shared_info *)((skb)->end))->nr_frags;
   skb_frag_t *frag = &((struct skb_shared_info *)((skb)->end))->frags[i-1];
   struct page *page = sk->sk_sndmsg_page;
   int off = sk->sk_sndmsg_off;
   unsigned int left;

   if (page && (left = (1UL << 12) - off) > 0) {
    if (copy >= left)
     copy = left;
    if (page != frag->page) {
     if (i == (65536/(1UL << 12) + 2)) {
      err = -90;
      goto error;
     }
     get_page(page);
      skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0);
     frag = &((struct skb_shared_info *)((skb)->end))->frags[i];
    }
   } else if (i < (65536/(1UL << 12) + 2)) {
    if (copy > (1UL << 12))
     copy = (1UL << 12);
    page = alloc_pages_node(((0)), sk->sk_allocation, 0);
    if (page == ((void *)0)) {
     err = -12;
     goto error;
    }
    sk->sk_sndmsg_page = page;
    sk->sk_sndmsg_off = 0;

    skb_fill_page_desc(skb, i, page, 0, 0);
    frag = &((struct skb_shared_info *)((skb)->end))->frags[i];
    skb->truesize += (1UL << 12);
    atomic_add((1UL << 12), &sk->sk_wmem_alloc);
   } else {
    err = -90;
    goto error;
   }
   if (getfrag(from, lowmem_page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) {
    err = -14;
    goto error;
   }
   sk->sk_sndmsg_off += copy;
   frag->size += copy;
   skb->len += copy;
   skb->data_len += copy;
  }
  offset += copy;
  length -= copy;
 }

 return 0;

error:
 inet->cork.length -= length;
 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_OUTDISCARDS]++);
 return err;
}

ssize_t ip_append_page(struct sock *sk, struct page *page,
         int offset, size_t size, int flags)
{
 struct inet_sock *inet = inet_sk(sk);
 struct sk_buff *skb;
 struct rtable *rt;
 struct ip_options *opt = ((void *)0);
 int hh_len;
 int mtu;
 int len;
 int err;
 unsigned int maxfraglen, fragheaderlen, fraggap;

 if (inet->hdrincl)
  return -1;

 if (flags&0x10)
  return 0;

 if (skb_queue_empty(&sk->sk_write_queue))
  return -22;

 rt = inet->cork.rt;
 if (inet->cork.flags & 1)
  opt = inet->cork.opt;

 if (!(rt->u.dst.dev->features&1))
  return -95;

 hh_len = (((rt->u.dst.dev)->hard_header_len&~(16 - 1)) + 16);
 mtu = inet->cork.fragsize;

 fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;

 if (inet->cork.length + size > 0xFFFF - fragheaderlen) {
  ip_local_error(sk, 90, rt->rt_dst, inet->dport, mtu);
  return -90;
 }

 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == ((void *)0))
  return -22;

 inet->cork.length += size;
 if ((sk->sk_protocol == IPPROTO_UDP) &&
     (rt->u.dst.dev->features & (SKB_GSO_UDP << 16))) {
  ((struct skb_shared_info *)((skb)->end))->gso_size = mtu - fragheaderlen;
  ((struct skb_shared_info *)((skb)->end))->gso_type = SKB_GSO_UDP;
 }


 while (size > 0) {
  int i;

  if (skb_is_gso(skb))
   len = size;
  else {


   len = mtu - skb->len;
   if (len < size)
    len = maxfraglen - skb->len;
  }
  if (len <= 0) {
   struct sk_buff *skb_prev;
   char *data;
   struct iphdr *iph;
   int alloclen;

   skb_prev = skb;
   fraggap = skb_prev->len - maxfraglen;

   alloclen = fragheaderlen + hh_len + fraggap + 15;
   skb = sock_wmalloc(sk, alloclen, 1, sk->sk_allocation);
   if (__builtin_expect(!!(!skb), 0)) {
    err = -105;
    goto error;
   }




   skb->ip_summed = 0;
   skb->csum = 0;
   skb_reserve(skb, hh_len);




   data = skb_put(skb, fragheaderlen + fraggap);
   skb->nh.iph = iph = (struct iphdr *)data;
   data += fragheaderlen;
   skb->h.raw = data;

   if (fraggap) {
    skb->csum = skb_copy_and_csum_bits(
     skb_prev, maxfraglen,
     data, fraggap, 0);
    skb_prev->csum = csum_sub(skb_prev->csum,
         skb->csum);
    pskb_trim_unique(skb_prev, maxfraglen);
   }




   __skb_queue_tail(&sk->sk_write_queue, skb);
   continue;
  }

  i = ((struct skb_shared_info *)((skb)->end))->nr_frags;
  if (len > size)
   len = size;
  if (skb_can_coalesce(skb, i, page, offset)) {
   ((struct skb_shared_info *)((skb)->end))->frags[i-1].size += len;
  } else if (i < (65536/(1UL << 12) + 2)) {
   get_page(page);
   skb_fill_page_desc(skb, i, page, offset, len);
  } else {
   err = -90;
   goto error;
  }

  if (skb->ip_summed == 0) {
   unsigned int csum;
   csum = csum_page(page, offset, len);
   skb->csum = csum_block_add(skb->csum, csum, skb->len);
  }

  skb->len += len;
  skb->data_len += len;
  offset += len;
  size -= len;
 }
 return 0;

error:
 inet->cork.length -= size;
 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_OUTDISCARDS]++);
 return err;
}





int ip_push_pending_frames(struct sock *sk)
{
 struct sk_buff *skb, *tmp_skb;
 struct sk_buff **tail_skb;
 struct inet_sock *inet = inet_sk(sk);
 struct ip_options *opt = ((void *)0);
 struct rtable *rt = inet->cork.rt;
 struct iphdr *iph;
 __be16 df = 0;
 __u8 ttl;
 int err = 0;

 if ((skb = __skb_dequeue(&sk->sk_write_queue)) == ((void *)0))
  goto out;
 tail_skb = &(((struct skb_shared_info *)((skb)->end))->frag_list);


 if (skb->data < skb->nh.raw)
  __skb_pull(skb, skb->nh.raw - skb->data);
 while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != ((void *)0)) {
  __skb_pull(tmp_skb, skb->h.raw - skb->nh.raw);
  *tail_skb = tmp_skb;
  tail_skb = &(tmp_skb->next);
  skb->len += tmp_skb->len;
  skb->data_len += tmp_skb->len;
  skb->truesize += tmp_skb->truesize;
  __sock_put(tmp_skb->sk);
  tmp_skb->destructor = ((void *)0);
  tmp_skb->sk = ((void *)0);
 }





 if (inet->pmtudisc != 2)
  skb->local_df = 1;




 if (inet->pmtudisc == 2 ||
     (skb->len <= dst_mtu(&rt->u.dst) &&
      ip_dont_fragment(sk, &rt->u.dst)))
  df = htons(0x4000);

 if (inet->cork.flags & 1)
  opt = inet->cork.opt;

 if (rt->rt_type == RTN_MULTICAST)
  ttl = inet->mc_ttl;
 else
  ttl = ip_select_ttl(inet, &rt->u.dst);

 iph = (struct iphdr *)skb->data;
 iph->version = 4;
 iph->ihl = 5;
 if (opt) {
  iph->ihl += opt->optlen>>2;
  ip_options_build(skb, opt, inet->cork.addr, rt, 0);
 }
 iph->tos = inet->tos;
 iph->tot_len = htons(skb->len);
 iph->frag_off = df;
 ip_select_ident(iph, &rt->u.dst, sk);
 iph->ttl = ttl;
 iph->protocol = sk->sk_protocol;
 iph->saddr = rt->rt_src;
 iph->daddr = rt->rt_dst;
 ip_send_check(iph);

 skb->priority = sk->sk_priority;
 skb->dst = dst_clone(&rt->u.dst);


 err = (dst_output)(skb);

 if (err) {
  if (err > 0)
   err = inet->recverr ? ((err) != 2 ? -105 : 0) : 0;
  if (err)
   goto error;
 }

out:
 inet->cork.flags &= ~1;
 kfree(inet->cork.opt);
 inet->cork.opt = ((void *)0);
 if (inet->cork.rt) {
  ip_rt_put(inet->cork.rt);
  inet->cork.rt = ((void *)0);
 }
 return err;

error:
 (({ (void)((0)); ((ip_statistics[!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))])); })->mibs[IPSTATS_MIB_OUTDISCARDS]++);
 goto out;
}




void ip_flush_pending_frames(struct sock *sk)
{
 struct inet_sock *inet = inet_sk(sk);
 struct sk_buff *skb;

 while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != ((void *)0))
  kfree_skb(skb);

 inet->cork.flags &= ~1;
 kfree(inet->cork.opt);
 inet->cork.opt = ((void *)0);
 if (inet->cork.rt) {
  ip_rt_put(inet->cork.rt);
  inet->cork.rt = ((void *)0);
 }
}





static int ip_reply_glue_bits(void *dptr, char *to, int offset,
         int len, int odd, struct sk_buff *skb)
{
 unsigned int csum;

 csum = csum_partial_copy((dptr+offset), (to), (len), (0));
 skb->csum = csum_block_add(skb->csum, csum, odd);
 return 0;
}
# 1335 "net/ipv4/ip_output.c"
void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg,
     unsigned int len)
{
 struct inet_sock *inet = inet_sk(sk);
 struct {
  struct ip_options opt;
  char data[40];
 } replyopts;
 struct ipcm_cookie ipc;
 __be32 daddr;
 struct rtable *rt = (struct rtable*)skb->dst;

 if (ip_options_echo(&replyopts.opt, skb))
  return;

 daddr = ipc.addr = rt->rt_src;
 ipc.opt = ((void *)0);

 if (replyopts.opt.optlen) {
  ipc.opt = &replyopts.opt;

  if (ipc.opt->srr)
   daddr = replyopts.opt.faddr;
 }

 {
  struct flowi fl = { .nl_u = { .ip4_u =
           { .daddr = daddr,
      .saddr = rt->rt_spec_dst,
      .tos = ((skb->nh.iph->tos)&0x1E) } },

        .uli_u = { .ports =
            { .sport = skb->h.th->dest,
              .dport = skb->h.th->source } },
        .proto = sk->sk_protocol };
  security_skb_classify_flow(skb, &fl);
  if (ip_route_output_key(&rt, &fl))
   return;
 }







 do { do { } while (0); (void)0; (void)(&((sk)->sk_lock.slock)); } while (0);
 inet->tos = skb->nh.iph->tos;
 sk->sk_priority = skb->priority;
 sk->sk_protocol = skb->nh.iph->protocol;
 ip_append_data(sk, ip_reply_glue_bits, arg->iov->iov_base, len, 0,
         &ipc, rt, 0x40);
 if ((skb = skb_peek(&sk->sk_write_queue)) != ((void *)0)) {
  if (arg->csumoffset >= 0)
   *((u16 *)skb->h.raw + arg->csumoffset) = csum_fold(csum_add(skb->csum, arg->csum));
  skb->ip_summed = 0;
  ip_push_pending_frames(sk);
 }

 do { do { } while (0); (void)0; (void)(&((sk)->sk_lock.slock)); } while (0);

 ip_rt_put(rt);
}

void __attribute__ ((__section__ (".init.text"))) ip_init(void)
{
 ip_rt_init();
 inet_initpeers();




}

extern typeof(ip_generic_getfrag) ip_generic_getfrag; static const char __kstrtab_ip_generic_getfrag[] __attribute__((section("__ksymtab_strings"))) = "_" "ip_generic_getfrag"; static const struct kernel_symbol __ksymtab_ip_generic_getfrag __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&ip_generic_getfrag, __kstrtab_ip_generic_getfrag };
extern typeof(ip_queue_xmit) ip_queue_xmit; static const char __kstrtab_ip_queue_xmit[] __attribute__((section("__ksymtab_strings"))) = "_" "ip_queue_xmit"; static const struct kernel_symbol __ksymtab_ip_queue_xmit __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&ip_queue_xmit, __kstrtab_ip_queue_xmit };
extern typeof(ip_send_check) ip_send_check; static const char __kstrtab_ip_send_check[] __attribute__((section("__ksymtab_strings"))) = "_" "ip_send_check"; static const struct kernel_symbol __ksymtab_ip_send_check __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&ip_send_check, __kstrtab_ip_send_check };