Attachment 307304 Details for Bug 449265 – gcc preprocessed source.

gcc preprocessed source.

crash_gcc_uml.txt (text/plain), 795.57 KB, created by Laurent Wandrebeck on 2008-06-01 10:08:42 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Laurent Wandrebeck

Created: 2008-06-01 10:08:42 UTC

Size: 795.57 KB

patch

obsolete

>// /usr/libexec/gcc/x86_64-redhat-linux/4.3.0/cc1 -fpreprocessed /home/low/.ccache/sched.tmp.a64.home.net.5896.i -quiet -dumpbase sched.tmp.a64.home.net.5896.i -m64 -mtune=generic -auxbase-strip /home/low/.ccache/tmp.hash.a64.home.net.5896.o -g -Os -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -Werror-implicit-function-declaration -Wdeclaration-after-statement -Wno-pointer-sign -fno-strict-aliasing -fno-common -fno-stack-protector -fno-builtin -fno-unit-at-a-time -fno-optimize-sibling-calls -fno-omit-frame-pointer -o - -frandom-seed=0
># 1 "kernel/sched.c"
># 1 "/home/low/dev/linux-2.6-low//"
># 1 "<interne>"
># 1 "<command-line>"
>
># 1 "./include/linux/autoconf.h" 1
># 1 "<command-line>" 2
># 1 "kernel/sched.c"
># 29 "kernel/sched.c"
>
># 1 "include/linux/mm.h" 1
>
>
>
>
># 1 "include/linux/errno.h" 1
>
>
>
>
># 1 "include/asm/errno.h" 1
>
>
>
>
># 1 "include/asm/arch/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
># 1 "include/asm/arch/errno.h" 2
># 5 "include/asm/errno.h" 2
># 5 "include/linux/errno.h" 2
># 5 "include/linux/mm.h" 2
>
>
>
>
># 1 "include/linux/gfp.h" 1
>
>
>
>
># 1 "include/linux/mmzone.h" 1
>
>
>
>
>
>
>
># 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
># 10 "include/linux/thread_info.h"
>
># 1 "include/linux/types.h" 1
># 11 "include/linux/types.h"
>
># 1 "include/linux/posix_types.h" 1
>
>
>
>
># 1 "include/linux/stddef.h" 1
>
>
>
>
># 1 "include/linux/compiler.h" 1
># 40 "include/linux/compiler.h"
>
># 1 "include/linux/compiler-gcc4.h" 1
>
>
>
>
>
>
># 1 "include/linux/compiler-gcc.h" 1
># 7 "include/linux/compiler-gcc4.h" 2
># 41 "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
>
>
>
>
># 1 "include/asm/arch/posix_types.h" 1
>
>
>
>
>
># 1 "include/asm/arch/posix_types_64.h" 1
># 10 "include/asm/arch/posix_types_64.h"
>typedef unsigned long __kernel_ino_t;
>typedef unsigned int __kernel_mode_t;
>typedef unsigned long __kernel_nlink_t;
>typedef long __kernel_off_t;
>typedef int __kernel_pid_t;
>typedef int __kernel_ipc_pid_t;
>typedef unsigned int __kernel_uid_t;
>typedef unsigned int __kernel_gid_t;
>typedef unsigned long __kernel_size_t;
>typedef long __kernel_ssize_t;
>typedef long __kernel_ptrdiff_t;
>typedef long __kernel_time_t;
>typedef long __kernel_suseconds_t;
>typedef long __kernel_clock_t;
>typedef int __kernel_timer_t;
>typedef int __kernel_clockid_t;
>typedef int __kernel_daddr_t;
>typedef char * __kernel_caddr_t;
>typedef unsigned short __kernel_uid16_t;
>typedef unsigned short __kernel_gid16_t;
>
>
>typedef long long __kernel_loff_t;
>
>
>typedef struct {
> int val[2];
>} __kernel_fsid_t;
>
>typedef unsigned short __kernel_old_uid_t;
>typedef unsigned short __kernel_old_gid_t;
>typedef __kernel_uid_t __kernel_uid32_t;
>typedef __kernel_gid_t __kernel_gid32_t;
>
>typedef unsigned long __kernel_old_dev_t;
>
>
>
>
>static inline __attribute__((always_inline)) void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp)
>{
> unsigned long _tmp = fd / (8 * sizeof(unsigned long));
> unsigned long _rem = fd % (8 * sizeof(unsigned long));
> fdsetp->fds_bits[_tmp] |= (1UL<<_rem);
>}
>
>
>static inline __attribute__((always_inline)) void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp)
>{
> unsigned long _tmp = fd / (8 * sizeof(unsigned long));
> unsigned long _rem = fd % (8 * sizeof(unsigned long));
> fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem);
>}
>
>
>static inline __attribute__((always_inline)) int __FD_ISSET(unsigned long fd, __const__ __kernel_fd_set *p)
>{
> unsigned long _tmp = fd / (8 * sizeof(unsigned long));
> unsigned long _rem = fd % (8 * sizeof(unsigned long));
> return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void __FD_ZERO(__kernel_fd_set *p)
>{
> unsigned long *tmp = p->fds_bits;
> int i;
>
> if (__builtin_constant_p((1024/(8 * sizeof(unsigned long))))) {
>  switch ((1024/(8 * sizeof(unsigned long)))) {
>  case 32:
>   tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
>   tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
>   tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0;
>   tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0;
>   tmp[16] = 0; tmp[17] = 0; tmp[18] = 0; tmp[19] = 0;
>   tmp[20] = 0; tmp[21] = 0; tmp[22] = 0; tmp[23] = 0;
>   tmp[24] = 0; tmp[25] = 0; tmp[26] = 0; tmp[27] = 0;
>   tmp[28] = 0; tmp[29] = 0; tmp[30] = 0; tmp[31] = 0;
>   return;
>  case 16:
>   tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
>   tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
>   tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0;
>   tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0;
>   return;
>  case 8:
>   tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
>   tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
>   return;
>  case 4:
>   tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
>   return;
>  }
> }
> i = (1024/(8 * sizeof(unsigned long)));
> while (i) {
>  i--;
>  *tmp = 0;
>  tmp++;
> }
>}
># 6 "include/asm/arch/posix_types.h" 2
># 5 "include/asm/posix_types.h" 2
># 48 "include/linux/posix_types.h" 2
># 12 "include/linux/types.h" 2
>
># 1 "include/asm/types.h" 1
>
>
>
>
># 1 "include/asm/arch/types.h" 1
>
>
>
>
># 1 "include/asm-generic/int-ll64.h" 1
># 17 "include/asm-generic/int-ll64.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;
>
>
>__extension__ typedef __signed__ long long __s64;
>__extension__ typedef unsigned long long __u64;
># 40 "include/asm-generic/int-ll64.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;
># 5 "include/asm/arch/types.h" 2
>
>
>
>typedef unsigned short umode_t;
># 25 "include/asm/arch/types.h"
>typedef u64 dma64_addr_t;
>
>
>
>
>typedef u32 dma_addr_t;
># 5 "include/asm/types.h" 2
># 13 "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 unsigned long uintptr_t;
>
>
>
>typedef __kernel_old_uid_t old_uid_t;
>typedef __kernel_old_gid_t old_gid_t;
># 57 "include/linux/types.h"
>typedef __kernel_loff_t loff_t;
># 66 "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;
># 151 "include/linux/types.h"
>typedef unsigned long blkcnt_t;
># 180 "include/linux/types.h"
>typedef __u16 __le16;
>typedef __u16 __be16;
>typedef __u32 __le32;
>typedef __u32 __be32;
>
>typedef __u64 __le64;
>typedef __u64 __be64;
>
>typedef __u16 __sum16;
>typedef __u32 __wsum;
>
>
>typedef unsigned gfp_t;
>
>
>typedef u64 resource_size_t;
>
>
>
>
>struct ustat {
> __kernel_daddr_t f_tfree;
> __kernel_ino_t f_tinode;
> char f_fname[6];
> char f_fpack[6];
>};
># 11 "include/linux/thread_info.h" 2
>
>struct timespec;
>struct compat_timespec;
>
>
>
>
>struct restart_block {
> long (*fn)(struct restart_block *);
> union {
>  struct {
>   unsigned long arg0, arg1, arg2, arg3;
>  };
>
>  struct {
>   u32 *uaddr;
>   u32 val;
>   u32 flags;
>   u32 bitset;
>   u64 time;
>  } futex;
>
>  struct {
>   clockid_t index;
>   struct timespec *rmtp;
>
>
>
>   u64 expires;
>  } nanosleep;
> };
>};
>
>extern long do_no_restart_syscall(struct restart_block *parm);
>
>
># 1 "include/linux/bitops.h" 1
># 17 "include/linux/bitops.h"
>
># 1 "include/asm/bitops.h" 1
># 9 "include/asm/bitops.h"
># 1 "include/asm/arch/bitops.h" 1
># 13 "include/asm/arch/bitops.h"
>
># 1 "include/asm/alternative.h" 1
>
>
>
>
># 1 "include/asm/arch/alternative.h" 1
>
>
>
>
>
>
># 1 "include/asm/asm.h" 1
>
>
>
>
># 1 "include/asm/arch/asm.h" 1
># 5 "include/asm/asm.h" 2
># 7 "include/asm/arch/alternative.h" 2
># 42 "include/asm/arch/alternative.h"
>
># 1 "include/asm/cpufeature.h" 1
>
>
>
>
># 1 "include/asm/arch/cpufeature.h" 1
>
>
>
>
>
>
>
># 1 "include/asm/required-features.h" 1
># 8 "include/asm/arch/cpufeature.h" 2
># 118 "include/asm/arch/cpufeature.h"
>
># 1 "include/linux/bitops.h" 1
># 119 "include/asm/arch/cpufeature.h" 2
>
>extern const char * const x86_cap_flags[8*32];
>extern const char * const x86_power_flags[32];
># 5 "include/asm/cpufeature.h" 2
># 43 "include/asm/arch/alternative.h" 2
>
>struct alt_instr {
> u8 *instr;
> u8 *replacement;
> u8 cpuid;
> u8 instrlen;
> u8 replacementlen;
> u8 pad1;
>
>
>
>};
>
>extern void alternative_instructions(void);
>extern void apply_alternatives(struct alt_instr *start, struct alt_instr *end);
>
>struct module;
># 68 "include/asm/arch/alternative.h"
>static inline __attribute__((always_inline)) void alternatives_smp_module_add(struct module *mod, char *name,
>            void *locks, void *locks_end,
>            void *text, void *text_end) {}
>static inline __attribute__((always_inline)) void alternatives_smp_module_del(struct module *mod) {}
>static inline __attribute__((always_inline)) void alternatives_smp_switch(int smp) {}
># 146 "include/asm/arch/alternative.h"
>struct paravirt_patch_site;
>
>
>
>
>static inline __attribute__((always_inline)) void apply_paravirt(struct paravirt_patch_site *start,
>      struct paravirt_patch_site *end)
>{}
>
>
>
>
>extern void add_nops(void *insns, unsigned int len);
># 178 "include/asm/arch/alternative.h"
>extern void *text_poke(void *addr, const void *opcode, size_t len);
>extern void *text_poke_early(void *addr, const void *opcode, size_t len);
># 5 "include/asm/alternative.h" 2
># 14 "include/asm/arch/bitops.h" 2
># 46 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void set_bit(int nr, volatile void *addr)
>{
> asm volatile("" "bts %1,%0" : "+m" (*(volatile long *) addr) : "Ir" (nr) : "memory");
>}
># 60 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void __set_bit(int nr, volatile void *addr)
>{
> asm volatile("bts %1,%0" : "+m" (*(volatile long *) addr) : "Ir" (nr) : "memory");
>}
># 75 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void clear_bit(int nr, volatile void *addr)
>{
> asm volatile("" "btr %1,%0" : "+m" (*(volatile long *) addr) : "Ir" (nr));
>}
># 88 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void clear_bit_unlock(unsigned nr, volatile void *addr)
>{
> __asm__ __volatile__("": : :"memory");
> clear_bit(nr, addr);
>}
>
>static inline __attribute__((always_inline)) void __clear_bit(int nr, volatile void *addr)
>{
> asm volatile("btr %1,%0" : "+m" (*(volatile long *) addr) : "Ir" (nr));
>}
># 111 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void __clear_bit_unlock(unsigned nr, volatile void *addr)
>{
> __asm__ __volatile__("": : :"memory");
> __clear_bit(nr, addr);
>}
># 129 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void __change_bit(int nr, volatile void *addr)
>{
> asm volatile("btc %1,%0" : "+m" (*(volatile long *) addr) : "Ir" (nr));
>}
># 143 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) void change_bit(int nr, volatile void *addr)
>{
> asm volatile("" "btc %1,%0" : "+m" (*(volatile long *) addr) : "Ir" (nr));
>}
># 156 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int test_and_set_bit(int nr, volatile void *addr)
>{
> int oldbit;
>
> asm volatile("" "bts %2,%1\n\t"
>       "sbb %0,%0" : "=r" (oldbit), "+m" (*(volatile long *) addr) : "Ir" (nr) : "memory");
>
> return oldbit;
>}
># 173 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int test_and_set_bit_lock(int nr, volatile void *addr)
>{
> return test_and_set_bit(nr, addr);
>}
># 187 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile void *addr)
>{
> int oldbit;
>
> asm("bts %2,%1\n\t"
>     "sbb %0,%0"
>     : "=r" (oldbit), "+m" (*(volatile long *) addr)
>     : "Ir" (nr));
> return oldbit;
>}
># 206 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile void *addr)
>{
> int oldbit;
>
> asm volatile("" "btr %2,%1\n\t"
>       "sbb %0,%0"
>       : "=r" (oldbit), "+m" (*(volatile long *) addr) : "Ir" (nr) : "memory");
>
> return oldbit;
>}
># 226 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile void *addr)
>{
> int oldbit;
>
> asm volatile("btr %2,%1\n\t"
>       "sbb %0,%0"
>       : "=r" (oldbit), "+m" (*(volatile long *) addr)
>       : "Ir" (nr));
> return oldbit;
>}
>
>
>static inline __attribute__((always_inline)) int __test_and_change_bit(int nr, volatile void *addr)
>{
> int oldbit;
>
> asm volatile("btc %2,%1\n\t"
>       "sbb %0,%0"
>       : "=r" (oldbit), "+m" (*(volatile long *) addr)
>       : "Ir" (nr) : "memory");
>
> return oldbit;
>}
># 258 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int test_and_change_bit(int nr, volatile void *addr)
>{
> int oldbit;
>
> asm volatile("" "btc %2,%1\n\t"
>       "sbb %0,%0"
>       : "=r" (oldbit), "+m" (*(volatile long *) addr) : "Ir" (nr) : "memory");
>
> return oldbit;
>}
>
>static inline __attribute__((always_inline)) int constant_test_bit(int nr, const volatile void *addr)
>{
> return ((1UL << (nr % 64)) &
>  (((unsigned long *)addr)[nr / 64])) != 0;
>}
>
>static inline __attribute__((always_inline)) int variable_test_bit(int nr, volatile const void *addr)
>{
> int oldbit;
>
> asm volatile("bt %2,%1\n\t"
>       "sbb %0,%0"
>       : "=r" (oldbit)
>       : "m" (*(unsigned long *)addr), "Ir" (nr));
>
> return oldbit;
>}
># 307 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) unsigned long __ffs(unsigned long word)
>{
> asm("bsf %1,%0"
>  : "=r" (word)
>  : "rm" (word));
> return word;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long ffz(unsigned long word)
>{
> asm("bsf %1,%0"
>  : "=r" (word)
>  : "r" (~word));
> return word;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long __fls(unsigned long word)
>{
> asm("bsr %1,%0"
>     : "=r" (word)
>     : "rm" (word));
> return word;
>}
># 355 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int ffs(int x)
>{
> int r;
>
>
>
>
>
> asm("bsfl %1,%0\n\t"
>     "jnz 1f\n\t"
>     "movl $-1,%0\n"
>     "1:" : "=r" (r) : "rm" (x));
>
> return r + 1;
>}
># 382 "include/asm/arch/bitops.h"
>static inline __attribute__((always_inline)) int fls(int x)
>{
> int r;
>
>
>
>
>
> asm("bsrl %1,%0\n\t"
>     "jnz 1f\n\t"
>     "movl $-1,%0\n"
>     "1:" : "=r" (r) : "rm" (x));
>
> return r + 1;
>}
>
>
>
>
>static inline __attribute__((always_inline)) void set_bit_string(unsigned long *bitmap,
>  unsigned long i, int len)
>{
> unsigned long end = i + len;
> while (i < end) {
>  __set_bit(i, bitmap);
>  i++;
> }
>}
>
>
>
>
># 1 "include/asm-generic/bitops/sched.h" 1
># 12 "include/asm-generic/bitops/sched.h"
>static inline __attribute__((always_inline)) int sched_find_first_bit(const unsigned long *b)
>{
>
> if (b[0])
>  return __ffs(b[0]);
> return __ffs(b[1]) + 64;
># 29 "include/asm-generic/bitops/sched.h"
>}
># 414 "include/asm/arch/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);
># 418 "include/asm/arch/bitops.h" 2
>
>
>
>
># 1 "include/asm-generic/bitops/fls64.h" 1
># 26 "include/asm-generic/bitops/fls64.h"
>static inline __attribute__((always_inline)) int fls64(__u64 x)
>{
> if (x == 0)
>  return 0;
> return __fls(x) + 1;
>}
># 422 "include/asm/arch/bitops.h" 2
>
>
>
>
># 1 "include/asm-generic/bitops/ext2-non-atomic.h" 1
>
>
>
>
># 1 "include/asm-generic/bitops/le.h" 1
>
>
>
>
>
># 1 "include/asm/byteorder.h" 1
>
>
>
>
># 1 "include/asm/arch/byteorder.h" 1
># 51 "include/asm/arch/byteorder.h"
>static inline __attribute__((always_inline)) __attribute__((__const__)) __u64 ___arch__swab64(__u64 x)
>{
> asm("bswapq %0"
>     : "=r" (x)
>     : "0" (x));
> return x;
>}
>
>static inline __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swab32(__u32 x)
>{
> asm("bswapl %0"
>     : "=r" (x)
>     : "0" (x));
> return x;
>}
># 79 "include/asm/arch/byteorder.h"
>
># 1 "include/linux/byteorder/little_endian.h" 1
># 12 "include/linux/byteorder/little_endian.h"
>
># 1 "include/linux/byteorder/swab.h" 1
># 64 "include/linux/byteorder/swab.h"
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 ___swab16(__u16 x)
>{
> return x<<8 | x>>8;
>}
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___swab32(__u32 x)
>{
> return x<<24 | x>>24 |
>  (x & (__u32)0x0000ff00UL)<<8 |
>  (x & (__u32)0x00ff0000UL)>>8;
>}
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 ___swab64(__u64 x)
>{
> return x<<56 | x>>56 |
>  (x & (__u64)0x000000000000ff00ULL)<<40 |
>  (x & (__u64)0x0000000000ff0000ULL)<<24 |
>  (x & (__u64)0x00000000ff000000ULL)<< 8 |
>         (x & (__u64)0x000000ff00000000ULL)>> 8 |
>  (x & (__u64)0x0000ff0000000000ULL)>>24 |
>  (x & (__u64)0x00ff000000000000ULL)>>40;
>}
># 163 "include/linux/byteorder/swab.h"
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 x)
>{
> return ___swab16(x);
>}
>static __inline__ __attribute__((always_inline)) __u16 __swab16p(const __u16 *x)
>{
> return ___swab16(*(x));
>}
>static __inline__ __attribute__((always_inline)) void __swab16s(__u16 *addr)
>{
> ((void)(*(addr) = ___swab16(*(addr))));
>}
>
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswab32(__u32 x)
>{
> return ___arch__swab32(x);
>}
>static __inline__ __attribute__((always_inline)) __u32 __swab32p(const __u32 *x)
>{
> return ___arch__swab32(*(x));
>}
>static __inline__ __attribute__((always_inline)) void __swab32s(__u32 *addr)
>{
> ((void)(*(addr) = ___arch__swab32(*(addr))));
>}
>
>
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 __fswab64(__u64 x)
>{
>
>
>
>
>
> return ___arch__swab64(x);
>
>}
>static __inline__ __attribute__((always_inline)) __u64 __swab64p(const __u64 *x)
>{
> return ___arch__swab64(*(x));
>}
>static __inline__ __attribute__((always_inline)) void __swab64s(__u64 *addr)
>{
> ((void)(*(addr) = ___arch__swab64(*(addr))));
>}
># 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);
>}
># 105 "include/linux/byteorder/little_endian.h"
>
># 1 "include/linux/byteorder/generic.h" 1
># 143 "include/linux/byteorder/generic.h"
>static inline __attribute__((always_inline)) void le16_add_cpu(__le16 *var, u16 val)
>{
> *var = (( __le16)(__u16)((( __u16)(__le16)(*var)) + val));
>}
>
>static inline __attribute__((always_inline)) void le32_add_cpu(__le32 *var, u32 val)
>{
> *var = (( __le32)(__u32)((( __u32)(__le32)(*var)) + val));
>}
>
>static inline __attribute__((always_inline)) void le64_add_cpu(__le64 *var, u64 val)
>{
> *var = (( __le64)(__u64)((( __u64)(__le64)(*var)) + val));
>}
>
>static inline __attribute__((always_inline)) void be16_add_cpu(__be16 *var, u16 val)
>{
> *var = (( __be16)(__builtin_constant_p((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)((( __u16)(__be16)(*var))) & (__u16)0x00ffU) << 8) | (((__u16)((( __u16)(__be16)(*var))) & (__u16)0xff00U) >> 8) )) : __fswab16((( __u16)(__be16)(*var)))) + val))) ? ((__u16)( (((__u16)((((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)((( __u16)(__be16)(*var))) & (__u16)0x00ffU) << 8) | (((__u16)((( __u16)(__be16)(*var))) & (__u16)0xff00U) >> 8) )) : __fswab16((( __u16)(__be16)(*var)))) + val))) & (__u16)0x00ffU) << 8) | (((__u16)((((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)((( __u16)(__be16)(*var))) & (__u16)0x00ffU) << 8) | (((__u16)((( __u16)(__be16)(*var))) & (__u16)0xff00U) >> 8) )) : __fswab16((( __u16)(__be16)(*var)))) + val))) & (__u16)0xff00U) >> 8) )) : __fswab16((((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)((( __u16)(__be16)(*var))) & (__u16)0x00ffU) << 8) | (((__u16)((( __u16)(__be16)(*var))) & (__u16)0xff00U) >> 8) )) : __fswab16((( __u16)(__be16)(*var)))) + val)))));
>}
>
>static inline __attribute__((always_inline)) void be32_add_cpu(__be32 *var, u32 val)
>{
> *var = (( __be32)(__builtin_constant_p((__u32)(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x000000ffUL) << 24) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((( __u32)(__be32)(*var)))) + val))) ? ((__u32)( (((__u32)((((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x000000ffUL) << 24) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((( __u32)(__be32)(*var)))) + val))) & (__u32)0x000000ffUL) << 24) | (((__u32)((((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x000000ffUL) << 24) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((( __u32)(__be32)(*var)))) + val))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x000000ffUL) << 24) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((( __u32)(__be32)(*var)))) + val))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x000000ffUL) << 24) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((( __u32)(__be32)(*var)))) + val))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x000000ffUL) << 24) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x0000ff00UL) << 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((( __u32)(__be32)(*var))) & (__u32)0xff000000UL) >> 24) )) : __fswab32((( __u32)(__be32)(*var)))) + val)))));
>}
>
>static inline __attribute__((always_inline)) void be64_add_cpu(__be64 *var, u64 val)
>{
> *var = (( __be64)(__builtin_constant_p((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) ? ((__u64)( (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)((( __u64)(__be64)(*var))) & (__u64)0xff00000000000000ULL) >> 56) )) : __fswab64((( __u64)(__be64)(*var)))) + val)))));
>}
># 106 "include/linux/byteorder/little_endian.h" 2
># 80 "include/asm/arch/byteorder.h" 2
># 5 "include/asm/byteorder.h" 2
># 6 "include/asm-generic/bitops/le.h" 2
># 5 "include/asm-generic/bitops/ext2-non-atomic.h" 2
># 426 "include/asm/arch/bitops.h" 2
>
>
>
>
>
>
>
># 1 "include/asm-generic/bitops/minix.h" 1
># 433 "include/asm/arch/bitops.h" 2
># 9 "include/asm/bitops.h" 2
># 18 "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)) __u16 rol16(__u16 word, unsigned int shift)
>{
> return (word << shift) | (word >> (16 - shift));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __u16 ror16(__u16 word, unsigned int shift)
>{
> return (word >> shift) | (word << (16 - shift));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __u8 rol8(__u8 word, unsigned int shift)
>{
> return (word << shift) | (word >> (8 - shift));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __u8 ror8(__u8 word, unsigned int shift)
>{
> return (word >> shift) | (word << (8 - shift));
>}
>
>static inline __attribute__((always_inline)) unsigned fls_long(unsigned long l)
>{
> if (sizeof(l) == 4)
>  return fls(l);
> return fls64(l);
>}
># 125 "include/linux/bitops.h"
>extern unsigned long find_first_bit(const unsigned long *addr,
>        unsigned long size);
># 135 "include/linux/bitops.h"
>extern unsigned long find_first_zero_bit(const unsigned long *addr,
>      unsigned long size);
># 148 "include/linux/bitops.h"
>extern unsigned long find_next_bit(const unsigned long *addr,
>       unsigned long size, unsigned long offset);
># 158 "include/linux/bitops.h"
>extern unsigned long find_next_zero_bit(const unsigned long *addr,
>     unsigned long size,
>     unsigned long offset);
># 47 "include/linux/thread_info.h" 2
>
># 1 "include/asm/thread_info.h" 1
># 12 "include/asm/thread_info.h"
>
># 1 "include/asm/page.h" 1
># 10 "include/asm/page.h"
>
># 1 "include/linux/const.h" 1
># 11 "include/asm/page.h" 2
># 19 "include/asm/page.h"
>struct page;
>
>
>
># 1 "include/asm/vm-flags.h" 1
># 16 "include/asm/vm-flags.h"
>extern unsigned long vm_stack_flags, vm_stack_flags32;
>extern unsigned long vm_data_default_flags, vm_data_default_flags32;
>extern unsigned long vm_force_exec32;
># 23 "include/asm/page.h" 2
># 60 "include/asm/page.h"
>typedef struct { unsigned long pte; } pte_t;
>typedef struct { unsigned long pgd; } pgd_t;
>
>
>typedef struct { unsigned long pmd; } pmd_t;
># 79 "include/asm/page.h"
>typedef unsigned long pfn_t;
>typedef unsigned long phys_t;
>
>
>
>typedef struct { unsigned long pgprot; } pgprot_t;
>
>typedef struct page *pgtable_t;
># 98 "include/asm/page.h"
>extern unsigned long uml_physmem;
>
>
>
>
>
>
>
># 1 "arch/um/include/mem.h" 1
># 9 "arch/um/include/mem.h"
>extern int phys_mapping(unsigned long phys, unsigned long long *offset_out);
>
>extern unsigned long uml_physmem;
>static inline __attribute__((always_inline)) unsigned long to_phys(void *virt)
>{
> return(((unsigned long) virt) - uml_physmem);
>}
>
>static inline __attribute__((always_inline)) void *to_virt(unsigned long phys)
>{
> return((void *) uml_physmem + phys);
>}
># 106 "include/asm/page.h" 2
># 121 "include/asm/page.h"
>extern struct page *arch_validate(struct page *page, gfp_t mask, int order);
>
>
>
># 1 "include/asm-generic/memory_model.h" 1
># 125 "include/asm/page.h" 2
>
># 1 "include/asm-generic/page.h" 1
># 9 "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;
>}
># 126 "include/asm/page.h" 2
># 13 "include/asm/thread_info.h" 2
>
># 1 "include/asm/uaccess.h" 1
># 10 "include/asm/uaccess.h"
>
># 1 "include/asm/processor.h" 1
># 11 "include/asm/processor.h"
>
># 1 "arch/um/include/sysdep/faultinfo.h" 1
># 18 "arch/um/include/sysdep/faultinfo.h"
>struct faultinfo {
>        int error_code;
>        unsigned long cr2;
>        int trap_no;
>};
># 12 "include/asm/processor.h" 2
>
>struct arch_thread {
>        unsigned long debugregs[8];
>        int debugregs_seq;
>        unsigned long fs;
>        struct faultinfo faultinfo;
>};
>
>
>static inline __attribute__((always_inline)) void rep_nop(void)
>{
> __asm__ __volatile__("rep;nop": : :"memory");
>}
># 33 "include/asm/processor.h"
>static inline __attribute__((always_inline)) void arch_flush_thread(struct arch_thread *thread)
>{
>}
>
>static inline __attribute__((always_inline)) void arch_copy_thread(struct arch_thread *from,
>                                    struct arch_thread *to)
>{
> to->fs = from->fs;
>}
>
>
># 1 "include/asm/arch/user.h" 1
>
>
>
>
># 1 "include/asm/arch/user_64.h" 1
># 50 "include/asm/arch/user_64.h"
>struct user_i387_struct {
> unsigned short cwd;
> unsigned short swd;
> unsigned short twd;
>
> unsigned short fop;
> __u64 rip;
> __u64 rdp;
> __u32 mxcsr;
> __u32 mxcsr_mask;
> __u32 st_space[32];
> __u32 xmm_space[64];
> __u32 padding[24];
>};
>
>
>
>
>struct user_regs_struct {
> unsigned long r15;
> unsigned long r14;
> unsigned long r13;
> unsigned long r12;
> unsigned long bp;
> unsigned long bx;
> unsigned long r11;
> unsigned long r10;
> unsigned long r9;
> unsigned long r8;
> unsigned long ax;
> unsigned long cx;
> unsigned long dx;
> unsigned long si;
> unsigned long di;
> unsigned long orig_ax;
> unsigned long ip;
> unsigned long cs;
> unsigned long flags;
> unsigned long sp;
> unsigned long ss;
> unsigned long fs_base;
> unsigned long gs_base;
> unsigned long ds;
> unsigned long es;
> unsigned long fs;
> unsigned long gs;
>};
>
>
>
>
>
>struct user {
>
>
>  struct user_regs_struct regs;
>
>  int u_fpvalid;
>
>  int pad0;
>  struct user_i387_struct i387;
>
>  unsigned long int u_tsize;
>  unsigned long int u_dsize;
>  unsigned long int u_ssize;
>  unsigned long start_code;
>  unsigned long start_stack;
>
>
>
>  long int signal;
>  int reserved;
>  int pad1;
>  unsigned long u_ar0;
>
>  struct user_i387_struct *u_fpstate;
>  unsigned long magic;
>  char u_comm[32];
>  unsigned long u_debugreg[8];
>  unsigned long error_code;
>  unsigned long fault_address;
>};
># 5 "include/asm/arch/user.h" 2
># 44 "include/asm/processor.h" 2
># 54 "include/asm/processor.h"
>
># 1 "include/asm/processor-generic.h" 1
># 9 "include/asm/processor-generic.h"
>struct pt_regs;
>
>struct task_struct;
>
>
># 1 "include/asm/ptrace.h" 1
># 12 "include/asm/ptrace.h"
>
># 1 "include/asm/host_ldt.h" 1
>
>
>
>
># 1 "include/asm/arch/ldt.h" 1
># 20 "include/asm/arch/ldt.h"
>struct user_desc {
> unsigned int entry_number;
> unsigned int base_addr;
> unsigned int limit;
> unsigned int seg_32bit:1;
> unsigned int contents:2;
> unsigned int read_exec_only:1;
> unsigned int limit_in_pages:1;
> unsigned int seg_not_present:1;
> unsigned int useable:1;
>
> unsigned int lm:1;
>
>};
># 5 "include/asm/host_ldt.h" 2
># 13 "include/asm/ptrace.h" 2
>
>
>
># 1 "include/asm/ptrace-generic.h" 1
># 11 "include/asm/ptrace-generic.h"
>
># 1 "include/asm/arch/ptrace-abi.h" 1
># 90 "include/asm/arch/ptrace-abi.h"
>struct ptrace_bts_config {
>
> __u32 size;
>
> __u32 flags;
>
> __u32 signal;
>
> __u32 bts_size;
>};
># 12 "include/asm/ptrace-generic.h" 2
>
># 1 "include/asm/user.h" 1
>
>
>
>
># 1 "include/asm/arch/user.h" 1
># 5 "include/asm/user.h" 2
># 13 "include/asm/ptrace-generic.h" 2
>
># 1 "arch/um/include/sysdep/ptrace.h" 1
># 11 "arch/um/include/sysdep/ptrace.h"
>
># 1 "arch/um/include/uml-config.h" 1
># 12 "arch/um/include/sysdep/ptrace.h" 2
>
># 1 "arch/um/include/user_constants.h" 1
># 13 "arch/um/include/sysdep/ptrace.h" 2
>
>
>
>
>
>
># 1 "arch/um/include/skas_ptregs.h" 1
>
>
>
>
># 1 "arch/um/include/user_constants.h" 1
># 5 "arch/um/include/skas_ptregs.h" 2
># 19 "arch/um/include/sysdep/ptrace.h" 2
># 87 "arch/um/include/sysdep/ptrace.h"
>struct uml_pt_regs {
> unsigned long gp[(((216)) / sizeof(unsigned long))];
> struct faultinfo faultinfo;
> long syscall;
> int is_user;
>};
># 129 "arch/um/include/sysdep/ptrace.h"
>extern int user_context(unsigned long sp);
># 140 "arch/um/include/sysdep/ptrace.h"
>struct syscall_args {
> unsigned long args[6];
>};
># 236 "arch/um/include/sysdep/ptrace.h"
>static inline __attribute__((always_inline)) void arch_init_registers(int pid)
>{
>}
># 14 "include/asm/ptrace-generic.h" 2
>
>struct pt_regs {
> struct uml_pt_regs regs;
>};
># 37 "include/asm/ptrace-generic.h"
>struct task_struct;
>
>extern long subarch_ptrace(struct task_struct *child, long request, long addr,
>      long data);
>extern unsigned long getreg(struct task_struct *child, int regno);
>extern int putreg(struct task_struct *child, int regno, unsigned long value);
>extern int get_fpregs(struct user_i387_struct *buf,
>        struct task_struct *child);
>extern int set_fpregs(struct user_i387_struct *buf,
>        struct task_struct *child);
>
>extern void show_regs(struct pt_regs *regs);
>
>extern void send_sigtrap(struct task_struct *tsk, struct uml_pt_regs *regs,
>    int error_code);
>
>extern int arch_copy_tls(struct task_struct *new);
>extern void clear_flushed_tls(struct task_struct *task);
># 16 "include/asm/ptrace.h" 2
># 67 "include/asm/ptrace.h"
>static inline __attribute__((always_inline)) int ptrace_get_thread_area(struct task_struct *child, int idx,
>                                         struct user_desc *user_desc)
>{
>        return -38;
>}
>
>static inline __attribute__((always_inline)) int ptrace_set_thread_area(struct task_struct *child, int idx,
>                                         struct user_desc *user_desc)
>{
>        return -38;
>}
>
>extern long arch_prctl(struct task_struct *task, int code,
>         unsigned long *addr);
># 14 "include/asm/processor-generic.h" 2
>
># 1 "arch/um/include/registers.h" 1
># 9 "arch/um/include/registers.h"
>
># 1 "arch/um/include/sysdep/ptrace.h" 1
># 10 "arch/um/include/registers.h" 2
>
># 1 "arch/um/include/sysdep/archsetjmp.h" 1
>
>
>
>
>
>
>
>struct __jmp_buf {
> unsigned long __rbx;
> unsigned long __rsp;
> unsigned long __rbp;
> unsigned long __r12;
> unsigned long __r13;
> unsigned long __r14;
> unsigned long __r15;
> unsigned long __rip;
>};
>
>typedef struct __jmp_buf jmp_buf[1];
># 11 "arch/um/include/registers.h" 2
>
>extern int save_fp_registers(int pid, unsigned long *fp_regs);
>extern int restore_fp_registers(int pid, unsigned long *fp_regs);
>extern int save_fpx_registers(int pid, unsigned long *fp_regs);
>extern int restore_fpx_registers(int pid, unsigned long *fp_regs);
>extern int save_registers(int pid, struct uml_pt_regs *regs);
>extern int restore_registers(int pid, struct uml_pt_regs *regs);
>extern int init_registers(int pid);
>extern void get_safe_registers(unsigned long *regs);
>extern unsigned long get_thread_reg(int reg, jmp_buf *buf);
>extern int get_fp_registers(int pid, unsigned long *regs);
>extern int put_fp_registers(int pid, unsigned long *regs);
># 15 "include/asm/processor-generic.h" 2
>
># 1 "arch/um/include/sysdep/archsetjmp.h" 1
># 16 "include/asm/processor-generic.h" 2
>
>struct mm_struct;
>
>struct thread_struct {
> struct task_struct *saved_task;
>
>
>
>
>
>
>
> int forking;
> struct pt_regs regs;
> int singlestep_syscall;
> void *fault_addr;
> jmp_buf *fault_catcher;
> struct task_struct *prev_sched;
> unsigned long temp_stack;
> jmp_buf *exec_buf;
> struct arch_thread arch;
> jmp_buf switch_buf;
> int mm_count;
> struct {
>  int op;
>  union {
>   struct {
>    int pid;
>   } fork, exec;
>   struct {
>    int (*proc)(void *);
>    void *arg;
>   } thread;
>   struct {
>    void (*proc)(void *);
>    void *arg;
>   } cb;
>  } u;
> } request;
>};
># 69 "include/asm/processor-generic.h"
>extern struct task_struct *alloc_task_struct(void);
>
>static inline __attribute__((always_inline)) void release_thread(struct task_struct *task)
>{
>}
>
>extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
>
>static inline __attribute__((always_inline)) void prepare_to_copy(struct task_struct *tsk)
>{
>}
>
>
>extern unsigned long thread_saved_pc(struct task_struct *t);
>
>static inline __attribute__((always_inline)) void mm_copy_segments(struct mm_struct *from_mm,
>        struct mm_struct *new_mm)
>{
>}
>
>
>
>
>
>
>extern unsigned long task_size;
>
>
>
>
>
>
>extern unsigned long stacksizelim;
># 112 "include/asm/processor-generic.h"
>extern void start_thread(struct pt_regs *regs, unsigned long entry,
>    unsigned long stack);
>
>struct cpuinfo_um {
> unsigned long loops_per_jiffy;
> int ipi_pipe[2];
>};
>
>extern struct cpuinfo_um boot_cpu_data;
># 134 "include/asm/processor-generic.h"
>extern unsigned long get_wchan(struct task_struct *p);
># 55 "include/asm/processor.h" 2
># 11 "include/asm/uaccess.h" 2
>
>
>typedef struct {
> unsigned long seg;
>} mm_segment_t;
>
>
># 1 "include/linux/thread_info.h" 1
># 18 "include/asm/uaccess.h" 2
># 41 "include/asm/uaccess.h"
>
># 1 "arch/um/include/um_uaccess.h" 1
># 9 "arch/um/include/um_uaccess.h"
>
># 1 "include/asm/elf.h" 1
># 11 "include/asm/elf.h"
>
># 1 "/home/low/dev/linux-2.6-low/arch/um/include/skas/skas.h" 1
># 11 "/home/low/dev/linux-2.6-low/arch/um/include/skas/skas.h"
>extern int userspace_pid[];
>extern int proc_mm, ptrace_faultinfo, ptrace_ldt;
>extern int skas_needs_stub;
>
>extern int user_thread(unsigned long stack, int flags);
>extern void new_thread_handler(void);
>extern void handle_syscall(struct uml_pt_regs *regs);
>extern int new_mm(unsigned long stack);
>extern void get_skas_faultinfo(int pid, struct faultinfo * fi);
>extern long execute_syscall_skas(void *r);
>extern unsigned long current_stub_stack(void);
># 12 "include/asm/elf.h" 2
># 34 "include/asm/elf.h"
>typedef unsigned long elf_greg_t;
>
>
>typedef elf_greg_t elf_gregset_t[(sizeof (struct user_regs_struct) / sizeof(elf_greg_t))];
>
>typedef struct user_i387_struct elf_fpregset_t;
># 98 "include/asm/elf.h"
>extern int elf_core_copy_fpregs(struct task_struct *t, elf_fpregset_t *fpu);
># 112 "include/asm/elf.h"
>extern long elf_aux_hwcap;
># 10 "arch/um/include/um_uaccess.h" 2
>
># 1 "include/asm/fixmap.h" 1
>
>
>
>
>
># 1 "include/asm/system.h" 1
># 10 "include/asm/system.h"
>
># 1 "include/asm/system-generic.h" 1
>
>
>
>
># 1 "include/asm/arch/system.h" 1
>
>
>
>
>
># 1 "include/asm/segment.h" 1
>
>
>
>extern int host_gdt_entry_tls_min;
># 6 "include/asm/arch/system.h" 2
>
>
># 1 "include/asm/cmpxchg.h" 1
>
>
>
>
># 1 "include/asm/arch/cmpxchg.h" 1
>
>
>
>
># 1 "include/asm/arch/cmpxchg_64.h" 1
># 11 "include/asm/arch/cmpxchg_64.h"
>static inline __attribute__((always_inline)) void set_64bit(volatile unsigned long *ptr, unsigned long val)
>{
> *ptr = val;
>}
># 23 "include/asm/arch/cmpxchg_64.h"
>static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void *ptr,
>       int size)
>{
> switch (size) {
> case 1:
>  asm volatile("xchgb %b0,%1"
>        : "=q" (x)
>        : "m" (*((volatile long *)(ptr))), "0" (x)
>        : "memory");
>  break;
> case 2:
>  asm volatile("xchgw %w0,%1"
>        : "=r" (x)
>        : "m" (*((volatile long *)(ptr))), "0" (x)
>        : "memory");
>  break;
> case 4:
>  asm volatile("xchgl %k0,%1"
>        : "=r" (x)
>        : "m" (*((volatile long *)(ptr))), "0" (x)
>        : "memory");
>  break;
> case 8:
>  asm volatile("xchgq %0,%1"
>        : "=r" (x)
>        : "m" (*((volatile long *)(ptr))), "0" (x)
>        : "memory");
>  break;
> }
> return x;
>}
># 63 "include/asm/arch/cmpxchg_64.h"
>static inline __attribute__((always_inline)) unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
>          unsigned long new, int size)
>{
> unsigned long prev;
> switch (size) {
> case 1:
>  asm volatile("" "cmpxchgb %b1,%2"
>        : "=a"(prev)
>        : "q"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> case 2:
>  asm volatile("" "cmpxchgw %w1,%2"
>        : "=a"(prev)
>        : "r"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> case 4:
>  asm volatile("" "cmpxchgl %k1,%2"
>        : "=a"(prev)
>        : "r"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> case 8:
>  asm volatile("" "cmpxchgq %1,%2"
>        : "=a"(prev)
>        : "r"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> }
> return old;
>}
>
>static inline __attribute__((always_inline)) unsigned long __cmpxchg_local(volatile void *ptr,
>         unsigned long old,
>         unsigned long new, int size)
>{
> unsigned long prev;
> switch (size) {
> case 1:
>  asm volatile("cmpxchgb %b1,%2"
>        : "=a"(prev)
>        : "q"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> case 2:
>  asm volatile("cmpxchgw %w1,%2"
>        : "=a"(prev)
>        : "r"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> case 4:
>  asm volatile("cmpxchgl %k1,%2"
>        : "=a"(prev)
>        : "r"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> case 8:
>  asm volatile("cmpxchgq %1,%2"
>        : "=a"(prev)
>        : "r"(new), "m"(*((volatile long *)(ptr))), "0"(old)
>        : "memory");
>  return prev;
> }
> return old;
>}
># 5 "include/asm/arch/cmpxchg.h" 2
># 5 "include/asm/cmpxchg.h" 2
># 8 "include/asm/arch/system.h" 2
>
># 1 "include/asm/nops.h" 1
>
>
>
>
># 1 "include/asm/arch/nops.h" 1
># 5 "include/asm/nops.h" 2
># 9 "include/asm/arch/system.h" 2
>
>
># 1 "include/linux/kernel.h" 1
># 10 "include/linux/kernel.h"
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.3.0/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.3.0/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 105 "/usr/lib/gcc/x86_64-redhat-linux/4.3.0/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 11 "include/linux/kernel.h" 2
>
># 1 "include/linux/linkage.h" 1
>
>
>
>
># 1 "include/asm/linkage.h" 1
>
>
>
>
># 1 "include/asm/arch/linkage.h" 1
># 5 "include/asm/linkage.h" 2
># 5 "include/linux/linkage.h" 2
># 12 "include/linux/kernel.h" 2
>
>
>
>
>
># 1 "include/linux/log2.h" 1
># 21 "include/linux/log2.h"
>extern __attribute__((const, noreturn))
>int ____ilog2_NaN(void);
># 31 "include/linux/log2.h"
>static inline __attribute__((always_inline)) __attribute__((const))
>int __ilog2_u32(u32 n)
>{
> return fls(n) - 1;
>}
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>int __ilog2_u64(u64 n)
>{
> return fls64(n) - 1;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>bool is_power_of_2(unsigned long n)
>{
> return (n != 0 && ((n & (n - 1)) == 0));
>}
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>unsigned long __roundup_pow_of_two(unsigned long n)
>{
> return 1UL << fls_long(n - 1);
>}
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>unsigned long __rounddown_pow_of_two(unsigned long n)
>{
> return 1UL << (fls_long(n) - 1);
>}
># 17 "include/linux/kernel.h" 2
>
>
># 1 "include/asm/bug.h" 1
>
>
>
>
># 1 "include/asm-generic/bug.h" 1
># 10 "include/asm-generic/bug.h"
>struct bug_entry {
> unsigned long bug_addr;
>
> const char *file;
> unsigned short line;
>
> unsigned short flags;
>};
># 36 "include/asm-generic/bug.h"
>extern void warn_on_slowpath(const char *file, const int line);
># 5 "include/asm/bug.h" 2
># 19 "include/linux/kernel.h" 2
>
>extern const char linux_banner[];
>extern const char linux_proc_banner[];
># 89 "include/linux/kernel.h"
>extern int console_printk[];
>
>
>
>
>
>
>struct completion;
>struct pt_regs;
>struct user;
># 132 "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))) __attribute__((__cold__));
>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 strict_strtoul(const char *, unsigned int, unsigned long *);
>extern int strict_strtol(const char *, unsigned int, long *);
>extern int strict_strtoull(const char *, unsigned int, unsigned long long *);
>extern int strict_strtoll(const char *, unsigned int, long long *);
>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 char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
>
>extern int sscanf(const char *, const char *, ...)
> __attribute__ ((format (scanf, 2, 3)));
>extern int vsscanf(const char *, const char *, va_list)
> __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);
>struct pid;
>extern struct pid *session_of_pgrp(struct pid *pgrp);
>
>
> int vprintk(const char *fmt, va_list args)
> __attribute__ ((format (printf, 1, 0)));
> int printk(const char * fmt, ...)
> __attribute__ ((format (printf, 1, 2))) __attribute__((__cold__));
>extern int log_buf_get_len(void);
>extern int log_buf_read(int idx);
>extern int log_buf_copy(char *dest, int idx, int len);
>
>extern int printk_ratelimit_jiffies;
>extern int printk_ratelimit_burst;
>extern int printk_ratelimit(void);
>extern int __ratelimit(int ratelimit_jiffies, int ratelimit_burst);
>extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);
>extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
>       unsigned int interval_msec);
># 216 "include/linux/kernel.h"
>extern void __attribute__((format(printf, 1, 2)))
> early_printk(const char *fmt, ...);
>
>unsigned long int_sqrt(unsigned long);
>
>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 void wake_up_klogd(void);
>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 int root_mountflags;
>
>
>extern enum system_states {
> SYSTEM_BOOTING,
> SYSTEM_RUNNING,
> SYSTEM_HALT,
> SYSTEM_POWER_OFF,
> SYSTEM_RESTART,
> SYSTEM_SUSPEND_DISK,
>} system_state;
># 264 "include/linux/kernel.h"
>extern void dump_stack(void) __attribute__((__cold__));
>
>enum {
> DUMP_PREFIX_NONE,
> DUMP_PREFIX_ADDRESS,
> DUMP_PREFIX_OFFSET
>};
>extern void hex_dump_to_buffer(const void *buf, size_t len,
>    int rowsize, int groupsize,
>    char *linebuf, size_t linebuflen, bool ascii);
>extern void print_hex_dump(const char *level, const char *prefix_str,
>    int prefix_type, int rowsize, int groupsize,
>    const void *buf, size_t len, bool ascii);
>extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
>   const void *buf, size_t len);
>
>extern const char hex_asc[];
>
>
>
>static inline __attribute__((always_inline)) char *pack_hex_byte(char *buf, u8 byte)
>{
> *buf++ = hex_asc[((byte) & 0xf0) >> 4];
> *buf++ = hex_asc[((byte) & 0x0f)];
> return buf;
>}
># 467 "include/linux/kernel.h"
>struct sysinfo;
>extern int do_sysinfo(struct sysinfo *info);
>
>
>
>
>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)];
>};
># 11 "include/asm/arch/system.h" 2
>
># 1 "include/linux/irqflags.h" 1
># 12 "include/asm/arch/system.h" 2
># 139 "include/asm/arch/system.h"
>extern void load_gs_index(unsigned);
># 165 "include/asm/arch/system.h"
>static inline __attribute__((always_inline)) unsigned long get_limit(unsigned long segment)
>{
> unsigned long __limit;
> asm("lsll %1,%0" : "=r" (__limit) : "r" (segment));
> return __limit + 1;
>}
>
>static inline __attribute__((always_inline)) void native_clts(void)
>{
> asm volatile("clts");
>}
># 184 "include/asm/arch/system.h"
>static unsigned long __force_order;
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr0(void)
>{
> unsigned long val;
> asm volatile("mov %%cr0,%0\n\t" : "=r" (val), "=m" (__force_order));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr0(unsigned long val)
>{
> asm volatile("mov %0,%%cr0": : "r" (val), "m" (__force_order));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr2(void)
>{
> unsigned long val;
> asm volatile("mov %%cr2,%0\n\t" : "=r" (val), "=m" (__force_order));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr2(unsigned long val)
>{
> asm volatile("mov %0,%%cr2": : "r" (val), "m" (__force_order));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr3(void)
>{
> unsigned long val;
> asm volatile("mov %%cr3,%0\n\t" : "=r" (val), "=m" (__force_order));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr3(unsigned long val)
>{
> asm volatile("mov %0,%%cr3": : "r" (val), "m" (__force_order));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr4(void)
>{
> unsigned long val;
> asm volatile("mov %%cr4,%0\n\t" : "=r" (val), "=m" (__force_order));
> return val;
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr4_safe(void)
>{
> unsigned long val;
># 240 "include/asm/arch/system.h"
> val = native_read_cr4();
>
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr4(unsigned long val)
>{
> asm volatile("mov %0,%%cr4": : "r" (val), "m" (__force_order));
>}
># 264 "include/asm/arch/system.h"
>static inline __attribute__((always_inline)) void native_wbinvd(void)
>{
> asm volatile("wbinvd": : :"memory");
>}
># 296 "include/asm/arch/system.h"
>static inline __attribute__((always_inline)) void clflush(volatile void *__p)
>{
> asm volatile("clflush %0" : "+m" (*(volatile char *)__p));
>}
>
>
>
>void disable_hlt(void);
>void enable_hlt(void);
>
>extern int es7000_plat;
>void cpu_idle_wait(void);
>
>extern unsigned long arch_align_stack(unsigned long sp);
>extern void free_init_pages(char *what, unsigned long begin, unsigned long end);
>
>void default_idle(void);
># 416 "include/asm/arch/system.h"
>static inline __attribute__((always_inline)) void rdtsc_barrier(void)
>{
> asm volatile ("661:\n\t" ".byte 0x8d,0x76,0x00\n" "\n662:\n" ".section .altinstructions,\"a\"\n" " .balign 8 " "\n" " .quad " "661b\n" " .quad " "663f\n" "	 .byte %c0\n" "	 .byte 662b-661b\n" "	 .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" "mfence" "\n664:\n" ".previous" :: "i" ((3*32+17)) : "memory");
> asm volatile ("661:\n\t" ".byte 0x8d,0x76,0x00\n" "\n662:\n" ".section .altinstructions,\"a\"\n" " .balign 8 " "\n" " .quad " "661b\n" " .quad " "663f\n" "	 .byte %c0\n" "	 .byte 662b-661b\n" "	 .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" "lfence" "\n664:\n" ".previous" :: "i" ((3*32+18)) : "memory");
>}
># 5 "include/asm/system-generic.h" 2
># 18 "include/asm/system-generic.h"
>extern void *switch_to(void *prev, void *next, void *last);
>
>extern int get_signals(void);
>extern int set_signals(int enable);
>extern int get_signals(void);
>extern void block_signals(void);
>extern void unblock_signals(void);
># 44 "include/asm/system-generic.h"
>extern void *_switch_to(void *prev, void *next, void *last);
># 11 "include/asm/system.h" 2
># 6 "include/asm/fixmap.h" 2
>
># 1 "include/asm/kmap_types.h" 1
># 11 "include/asm/kmap_types.h"
>enum km_type {
> KM_BOUNCE_READ,
> KM_SKB_SUNRPC_DATA,
> KM_SKB_DATA_SOFTIRQ,
> KM_USER0,
> KM_USER1,
> KM_UML_USERCOPY,
> KM_BIO_SRC_IRQ,
> KM_BIO_DST_IRQ,
> KM_PTE0,
> KM_PTE1,
> KM_IRQ0,
> KM_IRQ1,
> KM_SOFTIRQ0,
> KM_SOFTIRQ1,
> KM_TYPE_NR
>};
># 7 "include/asm/fixmap.h" 2
>
># 1 "include/asm/archparam.h" 1
># 8 "include/asm/fixmap.h" 2
># 35 "include/asm/fixmap.h"
>enum fixed_addresses {
>
>
>
>
> __end_of_fixed_addresses
>};
>
>extern void __set_fixmap (enum fixed_addresses idx,
>     unsigned long phys, pgprot_t flags);
># 68 "include/asm/fixmap.h"
>extern void __this_fixmap_does_not_exist(void);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long fix_to_virt(const unsigned int idx)
>{
># 86 "include/asm/fixmap.h"
> if (idx >= __end_of_fixed_addresses)
>  __this_fixmap_does_not_exist();
>
>        return (((task_size) - 2 * ((1UL) << 12)) - ((idx) << 12));
>}
>
>static inline __attribute__((always_inline)) unsigned long virt_to_fix(const unsigned long vaddr)
>{
>      do { if (__builtin_expect(!!(vaddr >= ((task_size) - 2 * ((1UL) << 12)) || vaddr < (((task_size) - 2 * ((1UL) << 12)) - (__end_of_fixed_addresses << 12))), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/fixmap.h", 94, (__func__)); panic("BUG!"); } while (0); } while(0);
>      return ((((task_size) - 2 * ((1UL) << 12)) - ((vaddr)&(~(((1UL) << 12)-1)))) >> 12);
>}
># 11 "arch/um/include/um_uaccess.h" 2
># 32 "arch/um/include/um_uaccess.h"
>extern int copy_from_user(void *to, const void *from, int n);
>extern int copy_to_user(void *to, const void *from, int n);
>
>extern int __do_copy_to_user(void *to, const void *from, int n,
>        void **fault_addr, jmp_buf **fault_catcher);
>extern void __do_copy(void *to, const void *from, int n);
># 58 "arch/um/include/um_uaccess.h"
>extern int strncpy_from_user(char *dst, const char *src, int count);
># 71 "arch/um/include/um_uaccess.h"
>extern int __clear_user(void *mem, int len);
># 83 "arch/um/include/um_uaccess.h"
>extern int clear_user(void *mem, int len);
># 96 "arch/um/include/um_uaccess.h"
>extern int strnlen_user(const void *str, int len);
># 42 "include/asm/uaccess.h" 2
># 93 "include/asm/uaccess.h"
>struct exception_table_entry
>{
>        unsigned long insn;
> unsigned long fixup;
>};
># 14 "include/asm/thread_info.h" 2
>
>struct thread_info {
> struct task_struct *task;
> struct exec_domain *exec_domain;
> unsigned long flags;
> __u32 cpu;
> int preempt_count;
>
> mm_segment_t addr_limit;
>
>
> struct restart_block restart_block;
> struct thread_info *real_thread;
>};
># 48 "include/asm/thread_info.h"
>static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
>{
> struct thread_info *ti;
> unsigned long mask = ((1 << 1) * ((1UL) << 12)) - 1;
> ti = (struct thread_info *) (((unsigned long) &ti) & ~mask);
> return ti;
>}
># 48 "include/linux/thread_info.h" 2
># 56 "include/linux/thread_info.h"
>static inline __attribute__((always_inline)) void set_ti_thread_flag(struct thread_info *ti, int flag)
>{
> set_bit(flag, (unsigned long *)&ti->flags);
>}
>
>static inline __attribute__((always_inline)) void clear_ti_thread_flag(struct thread_info *ti, int flag)
>{
> clear_bit(flag, (unsigned long *)&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, (unsigned long *)&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, (unsigned long *)&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), ((unsigned long *)&ti->flags)) : variable_test_bit((flag), ((unsigned long *)&ti->flags)));
>}
># 113 "include/linux/thread_info.h"
>static inline __attribute__((always_inline)) void set_restore_sigmask(void)
>{
> set_ti_thread_flag(current_thread_info(), 7);
> set_ti_thread_flag(current_thread_info(), 1);
>}
># 10 "include/linux/preempt.h" 2
>
>
># 1 "include/linux/list.h" 1
>
>
>
>
>
># 1 "include/linux/poison.h" 1
># 6 "include/linux/list.h" 2
>
># 1 "include/linux/prefetch.h" 1
># 15 "include/linux/prefetch.h"
>
># 1 "include/asm/cache.h" 1
># 16 "include/linux/prefetch.h" 2
># 53 "include/linux/prefetch.h"
>static inline __attribute__((always_inline)) void prefetch_range(void *addr, size_t len)
>{
>
>
>
>
>
>
>
>}
># 7 "include/linux/list.h" 2
># 19 "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;
>}
># 41 "include/linux/list.h"
>static inline __attribute__((always_inline)) void __list_add(struct list_head *new,
>         struct list_head *prev,
>         struct list_head *next)
>{
> next->prev = new;
> new->next = next;
> new->prev = prev;
> prev->next = new;
>}
># 65 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
>{
> __list_add(new, head, head->next);
>}
># 82 "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;
>}
># 119 "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);
>}
># 140 "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);
>}
># 153 "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;
>}
># 166 "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);
>}
># 200 "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);
>}
># 213 "include/linux/list.h"
>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);
>}
># 237 "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;
>}
># 314 "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)) int list_is_singular(const struct list_head *head)
>{
> return !list_empty(head) && (head->next == head->prev);
>}
>
>static inline __attribute__((always_inline)) void __list_splice(const 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(const struct list_head *list,
>    struct list_head *head)
>{
> if (!list_empty(list))
>  __list_splice(list, head);
>}
># 362 "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);
> }
>}
># 388 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_splice_init_rcu(struct list_head *list,
>     struct list_head *head,
>     void (*sync)(void))
>{
> struct list_head *first = list->next;
> struct list_head *last = list->prev;
> struct list_head *at = head->next;
>
> if (list_empty(head))
>  return;
>
>
>
> INIT_LIST_HEAD(list);
># 410 "include/linux/list.h"
> sync();
># 420 "include/linux/list.h"
> last->next = at;
> __asm__ __volatile__("": : :"memory");
> head->next = first;
> first->prev = head;
> at->prev = last;
>}
># 690 "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);
>}
># 752 "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);
> }
>}
># 773 "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;
>}
># 817 "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;
>}
># 868 "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;
>}
># 896 "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;
>}
># 12 "include/linux/preempt.h" 2
># 50 "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
># 15 "include/linux/spinlock_types.h"
>
># 1 "include/linux/spinlock_types_up.h" 1
># 25 "include/linux/spinlock_types_up.h"
>typedef struct { } raw_spinlock_t;
>
>
>
>
>
>typedef struct {
>
>} raw_rwlock_t;
># 16 "include/linux/spinlock_types.h" 2
>
>
>
># 1 "include/linux/lockdep.h" 1
># 12 "include/linux/lockdep.h"
>struct task_struct;
>struct lockdep_map;
># 313 "include/linux/lockdep.h"
>static inline __attribute__((always_inline)) void lockdep_off(void)
>{
>}
>
>static inline __attribute__((always_inline)) void lockdep_on(void)
>{
>}
># 340 "include/linux/lockdep.h"
>struct lock_class_key { };
># 373 "include/linux/lockdep.h"
>static inline __attribute__((always_inline)) void early_init_irq_lock_class(void)
>{
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void early_boot_irqs_off(void)
>{
>}
>static inline __attribute__((always_inline)) void early_boot_irqs_on(void)
>{
>}
>static inline __attribute__((always_inline)) void print_irqtrace_events(struct task_struct *curr)
>{
>}
># 19 "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);
># 90 "include/linux/spinlock.h"
># 1 "include/linux/spinlock_up.h" 1
># 90 "include/linux/spinlock.h" 2
># 141 "include/linux/spinlock.h"
>
># 1 "include/linux/spinlock_api_up.h" 1
># 142 "include/linux/spinlock.h" 2
># 302 "include/linux/spinlock.h"
>
># 1 "include/asm/atomic.h" 1
># 9 "include/asm/atomic.h"
>
># 1 "include/asm/arch/atomic.h" 1
>
>
>
>
># 1 "include/asm/arch/atomic_64.h" 1
># 25 "include/asm/arch/atomic_64.h"
>typedef struct {
> int counter;
>} atomic_t;
># 55 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) void atomic_add(int i, atomic_t *v)
>{
> asm volatile("" "addl %1,%0"
>       : "=m" (v->counter)
>       : "ir" (i), "m" (v->counter));
>}
># 69 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) void atomic_sub(int i, atomic_t *v)
>{
> asm volatile("" "subl %1,%0"
>       : "=m" (v->counter)
>       : "ir" (i), "m" (v->counter));
>}
># 85 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic_sub_and_test(int i, atomic_t *v)
>{
> unsigned char c;
>
> asm volatile("" "subl %2,%0; sete %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "ir" (i), "m" (v->counter) : "memory");
> return c;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void atomic_inc(atomic_t *v)
>{
> asm volatile("" "incl %0"
>       : "=m" (v->counter)
>       : "m" (v->counter));
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void atomic_dec(atomic_t *v)
>{
> asm volatile("" "decl %0"
>       : "=m" (v->counter)
>       : "m" (v->counter));
>}
># 129 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic_dec_and_test(atomic_t *v)
>{
> unsigned char c;
>
> asm volatile("" "decl %0; sete %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "m" (v->counter) : "memory");
> return c != 0;
>}
># 147 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic_inc_and_test(atomic_t *v)
>{
> unsigned char c;
>
> asm volatile("" "incl %0; sete %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "m" (v->counter) : "memory");
> return c != 0;
>}
># 166 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic_add_negative(int i, atomic_t *v)
>{
> unsigned char c;
>
> asm volatile("" "addl %2,%0; sets %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "ir" (i), "m" (v->counter) : "memory");
> return c;
>}
># 183 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic_add_return(int i, atomic_t *v)
>{
> int __i = i;
> asm volatile("" "xaddl %0, %1"
>       : "+r" (i), "+m" (v->counter)
>       : : "memory");
> return i + __i;
>}
>
>static inline __attribute__((always_inline)) int atomic_sub_return(int i, atomic_t *v)
>{
> return atomic_add_return(-i, v);
>}
>
>
>
>
>
>
>typedef struct {
> long counter;
>} atomic64_t;
># 233 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) void atomic64_add(long i, atomic64_t *v)
>{
> asm volatile("" "addq %1,%0"
>       : "=m" (v->counter)
>       : "ir" (i), "m" (v->counter));
>}
># 247 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) void atomic64_sub(long i, atomic64_t *v)
>{
> asm volatile("" "subq %1,%0"
>       : "=m" (v->counter)
>       : "ir" (i), "m" (v->counter));
>}
># 263 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic64_sub_and_test(long i, atomic64_t *v)
>{
> unsigned char c;
>
> asm volatile("" "subq %2,%0; sete %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "ir" (i), "m" (v->counter) : "memory");
> return c;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void atomic64_inc(atomic64_t *v)
>{
> asm volatile("" "incq %0"
>       : "=m" (v->counter)
>       : "m" (v->counter));
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void atomic64_dec(atomic64_t *v)
>{
> asm volatile("" "decq %0"
>       : "=m" (v->counter)
>       : "m" (v->counter));
>}
># 307 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic64_dec_and_test(atomic64_t *v)
>{
> unsigned char c;
>
> asm volatile("" "decq %0; sete %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "m" (v->counter) : "memory");
> return c != 0;
>}
># 325 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic64_inc_and_test(atomic64_t *v)
>{
> unsigned char c;
>
> asm volatile("" "incq %0; sete %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "m" (v->counter) : "memory");
> return c != 0;
>}
># 344 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic64_add_negative(long i, atomic64_t *v)
>{
> unsigned char c;
>
> asm volatile("" "addq %2,%0; sets %1"
>       : "=m" (v->counter), "=qm" (c)
>       : "ir" (i), "m" (v->counter) : "memory");
> return c;
>}
># 361 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) long atomic64_add_return(long i, atomic64_t *v)
>{
> long __i = i;
> asm volatile("" "xaddq %0, %1;"
>       : "+r" (i), "+m" (v->counter)
>       : : "memory");
> return i + __i;
>}
>
>static inline __attribute__((always_inline)) long atomic64_sub_return(long i, atomic64_t *v)
>{
> return atomic64_add_return(-i, v);
>}
># 393 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic_add_unless(atomic_t *v, int a, int u)
>{
> int c, old;
> c = ((v)->counter);
> for (;;) {
>  if (__builtin_expect(!!(c == (u)), 0))
>   break;
>  old = (((__typeof__(*(&(((v))->counter))))__cmpxchg((&(((v))->counter)), (unsigned long)((c)), (unsigned long)((c + (a))), sizeof(*(&(((v))->counter))))));
>  if (__builtin_expect(!!(old == c), 1))
>   break;
>  c = old;
> }
> return c != (u);
>}
># 419 "include/asm/arch/atomic_64.h"
>static inline __attribute__((always_inline)) int atomic64_add_unless(atomic64_t *v, long a, long u)
>{
> long c, old;
> c = ((v)->counter);
> for (;;) {
>  if (__builtin_expect(!!(c == (u)), 0))
>   break;
>  old = (((__typeof__(*(&(((v))->counter))))__cmpxchg((&(((v))->counter)), (unsigned long)((c)), (unsigned long)((c + (a))), sizeof(*(&(((v))->counter))))));
>  if (__builtin_expect(!!(old == c), 1))
>   break;
>  c = old;
> }
> return c != (u);
>}
># 452 "include/asm/arch/atomic_64.h"
>
># 1 "include/asm-generic/atomic.h" 1
># 23 "include/asm-generic/atomic.h"
>typedef atomic64_t atomic_long_t;
>
>
>
>static inline __attribute__((always_inline)) long atomic_long_read(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return (long)((v)->counter);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_set(atomic_long_t *l, long i)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> (((v)->counter) = (i));
>}
>
>static inline __attribute__((always_inline)) void atomic_long_inc(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> atomic64_inc(v);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_dec(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> atomic64_dec(v);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_add(long i, atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> atomic64_add(i, v);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_sub(long i, atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> atomic64_sub(i, v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_sub_and_test(long i, atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return atomic64_sub_and_test(i, v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_dec_and_test(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return atomic64_dec_and_test(v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_inc_and_test(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return atomic64_inc_and_test(v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_add_negative(long i, atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return atomic64_add_negative(i, v);
>}
>
>static inline __attribute__((always_inline)) long atomic_long_add_return(long i, atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return (long)atomic64_add_return(i, v);
>}
>
>static inline __attribute__((always_inline)) long atomic_long_sub_return(long i, atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return (long)atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((always_inline)) long atomic_long_inc_return(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return (long)(atomic64_add_return(1, (v)));
>}
>
>static inline __attribute__((always_inline)) long atomic_long_dec_return(atomic_long_t *l)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return (long)(atomic64_sub_return(1, (v)));
>}
>
>static inline __attribute__((always_inline)) long atomic_long_add_unless(atomic_long_t *l, long a, long u)
>{
> atomic64_t *v = (atomic64_t *)l;
>
> return (long)atomic64_add_unless(v, a, u);
>}
># 453 "include/asm/arch/atomic_64.h" 2
># 5 "include/asm/arch/atomic.h" 2
># 10 "include/asm/atomic.h" 2
># 303 "include/linux/spinlock.h" 2
># 311 "include/linux/spinlock.h"
>extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
># 8 "include/linux/mmzone.h" 2
>
>
># 1 "include/linux/wait.h" 1
># 26 "include/linux/wait.h"
>
># 1 "include/asm/current.h" 1
># 27 "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);
># 409 "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);
># 485 "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)) : variable_test_bit((bit), (word))))
>  return 0;
> return out_of_line_wait_on_bit(word, bit, action, mode);
>}
># 509 "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);
>}
># 10 "include/linux/mmzone.h" 2
>
>
># 1 "include/linux/cache.h" 1
># 12 "include/linux/mmzone.h" 2
>
># 1 "include/linux/threads.h" 1
># 13 "include/linux/mmzone.h" 2
>
># 1 "include/linux/numa.h" 1
># 14 "include/linux/mmzone.h" 2
>
># 1 "include/linux/init.h" 1
># 135 "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 __attribute__ ((__section__(".init.data"))) boot_command_line[];
>extern char *saved_command_line;
>extern unsigned int reset_devices;
>
>
>void setup_arch(char **);
>void prepare_namespace(void);
>
>extern void (*late_time_init)(void);
># 209 "include/linux/init.h"
>struct obs_kernel_param {
> const char *str;
> int (*setup_func)(char *);
> int early;
>};
># 240 "include/linux/init.h"
>void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) parse_early_param(void);
># 15 "include/linux/mmzone.h" 2
>
># 1 "include/linux/seqlock.h" 1
># 32 "include/linux/seqlock.h"
>typedef struct {
> unsigned sequence;
> spinlock_t lock;
>} seqlock_t;
># 60 "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;
>
>repeat:
> ret = sl->sequence;
> __asm__ __volatile__("": : :"memory");
> if (__builtin_expect(!!(ret & 1), 0)) {
>  rep_nop();
>  goto repeat;
> }
>
> return ret;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) int read_seqretry(const seqlock_t *sl, unsigned start)
>{
> __asm__ __volatile__("": : :"memory");
>
> return (sl->sequence != start);
>}
># 121 "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;
>
>repeat:
> ret = s->sequence;
> __asm__ __volatile__("": : :"memory");
> if (__builtin_expect(!!(ret & 1), 0)) {
>  rep_nop();
>  goto repeat;
> }
> return ret;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int read_seqcount_retry(const seqcount_t *s, unsigned start)
>{
> __asm__ __volatile__("": : :"memory");
>
> return s->sequence != start;
>}
>
>
>
>
>
>
>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++;
>}
># 16 "include/linux/mmzone.h" 2
>
># 1 "include/linux/nodemask.h" 1
># 89 "include/linux/nodemask.h"
>
># 1 "include/linux/bitmap.h" 1
># 9 "include/linux/bitmap.h"
># 1 "include/linux/string.h" 1
># 14 "include/linux/string.h"
>extern char *strndup_user(const char *, long);
>
>
>
>
>
># 1 "include/asm/string.h" 1
>
>
>
>
># 1 "include/asm/arch/string.h" 1
>
>
>
>
># 1 "include/asm/arch/string_64.h" 1
># 9 "include/asm/arch/string_64.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) void *__inline_memcpy(void *to, const void *from, size_t n)
>{
> unsigned long d0, d1, d2;
> asm volatile("rep ; movsl\n\t"
>       "testb $2,%b4\n\t"
>       "je 1f\n\t"
>       "movsw\n"
>       "1:\ttestb $1,%b4\n\t"
>       "je 2f\n\t"
>       "movsb\n"
>       "2:"
>       : "=&c" (d0), "=&D" (d1), "=&S" (d2)
>       : "0" (n / 4), "q" (n), "1" ((long)to), "2" ((long)from)
>       : "memory");
> return to;
>}
>
>
>
>
>
>
>extern void *memcpy(void *to, const void *from, size_t len);
># 47 "include/asm/arch/string_64.h"
>void *memset(void *s, int c, size_t n);
>
>
>void *memmove(void *dest, const void *src, size_t count);
>
>int memcmp(const void *cs, const void *ct, size_t count);
>size_t strlen(const char *s);
>char *strcpy(char *dest, const char *src);
>char *strcat(char *dest, const char *src);
>int strcmp(const char *cs, const char *ct);
># 5 "include/asm/arch/string.h" 2
># 5 "include/asm/string.h" 2
># 20 "include/linux/string.h" 2
>
>
>extern char * strcpy(char *,const char *);
>
>
>extern char * strncpy(char *,const char *, __kernel_size_t);
>
>
>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);
>
>
>extern int strcmp(const char *,const char *);
>
>
>extern int strncmp(const char *,const char *,__kernel_size_t);
>
>
>extern int strnicmp(const char *, const char *, __kernel_size_t);
>
>
>extern int strcasecmp(const char *s1, const char *s2);
>
>
>extern int strncasecmp(const char *s1, const char *s2, size_t n);
>
>
>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 *);
># 96 "include/linux/string.h"
>extern void * memscan(void *,int,__kernel_size_t);
>
>
>extern int memcmp(const void *,const void *,__kernel_size_t);
>
>
>extern void * memchr(const void *,int,__kernel_size_t);
>
>
>extern char *kstrdup(const char *s, gfp_t gfp);
>extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
>extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
>
>extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
>extern void argv_free(char **argv);
>
>extern bool sysfs_streq(const char *s1, const char *s2);
># 9 "include/linux/bitmap.h" 2
># 87 "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 void bitmap_onto(unsigned long *dst, const unsigned long *orig,
>  const unsigned long *relmap, int bits);
>extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
>  int sz, 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 <= 64)
>  *dst = 0UL;
> else {
>  int len = (((nbits) + (8 * sizeof(long)) - 1) / (8 * sizeof(long))) * sizeof(unsigned long);
>  memset(dst, 0, len);
> }
>}
>
>static inline __attribute__((always_inline)) void bitmap_fill(unsigned long *dst, int nbits)
>{
> size_t nlongs = (((nbits) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)));
> if (nlongs > 1) {
>  int len = (nlongs - 1) * sizeof(unsigned long);
>  memset(dst, 0xff, len);
> }
> dst[nlongs - 1] = ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL );
>}
>
>static inline __attribute__((always_inline)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
>   int nbits)
>{
> if (nbits <= 64)
>  *dst = *src;
> else {
>  int len = (((nbits) + (8 * sizeof(long)) - 1) / (8 * sizeof(long))) * 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 <= 64)
>  *dst = *src1 & *src2;
> else
>  __bitmap_and(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_or(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 64)
>  *dst = *src1 | *src2;
> else
>  __bitmap_or(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_xor(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 64)
>  *dst = *src1 ^ *src2;
> else
>  __bitmap_xor(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_andnot(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 64)
>  *dst = *src1 & ~(*src2);
> else
>  __bitmap_andnot(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
>   int nbits)
>{
> if (nbits <= 64)
>  *dst = ~(*src) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL );
> else
>  __bitmap_complement(dst, src, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_equal(const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 64)
>  return ! ((*src1 ^ *src2) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
> else
>  return __bitmap_equal(src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_intersects(const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 64)
>  return ((*src1 & *src2) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL )) != 0;
> else
>  return __bitmap_intersects(src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_subset(const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 64)
>  return ! ((*src1 & ~(*src2)) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
> else
>  return __bitmap_subset(src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_empty(const unsigned long *src, int nbits)
>{
> if (nbits <= 64)
>  return ! (*src & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
> else
>  return __bitmap_empty(src, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_full(const unsigned long *src, int nbits)
>{
> if (nbits <= 64)
>  return ! (~(*src) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL ));
> else
>  return __bitmap_full(src, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_weight(const unsigned long *src, int nbits)
>{
> if (nbits <= 64)
>  return hweight_long(*src & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-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 <= 64)
>  *dst = *src >> n;
> else
>  __bitmap_shift_right(dst, src, n, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_shift_left(unsigned long *dst,
>   const unsigned long *src, int n, int nbits)
>{
> if (nbits <= 64)
>  *dst = (*src << n) & ( ((nbits) % 64) ? (1UL<<((nbits) % 64))-1 : ~0UL );
> else
>  __bitmap_shift_left(dst, src, n, nbits);
>}
>
>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);
>}
># 90 "include/linux/nodemask.h" 2
>
>
>typedef struct { unsigned long bits[((((1 << 0)) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))]; } 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 __min1 = ((1 << 0)); int __min2 = (find_first_bit(srcp->bits, (1 << 0))); __min1 < __min2 ? __min1: __min2; });
>}
>
>
>static inline __attribute__((always_inline)) int __next_node(int n, const nodemask_t *srcp)
>{
> return ({ int __min1 = ((1 << 0)); int __min2 = (find_next_bit(srcp->bits, (1 << 0), n+1)); __min1 < __min2 ? __min1: __min2; });
>}
># 255 "include/linux/nodemask.h"
>static inline __attribute__((always_inline)) int __first_unset_node(const nodemask_t *maskp)
>{
> return ({ int __min1 = ((1 << 0)); int __min2 = (find_first_zero_bit(maskp->bits, (1 << 0))); __min1 < __min2 ? __min1: __min2; });
>
>}
># 289 "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);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_onto(nodemask_t *dstp, const nodemask_t *origp,
>  const nodemask_t *relmapp, int nbits)
>{
> bitmap_onto(dstp->bits, origp->bits, relmapp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_fold(nodemask_t *dstp, const nodemask_t *origp,
>  int sz, int nbits)
>{
> bitmap_fold(dstp->bits, origp->bits, sz, nbits);
>}
># 363 "include/linux/nodemask.h"
>enum node_states {
> N_POSSIBLE,
> N_ONLINE,
> N_NORMAL_MEMORY,
>
>
>
> N_HIGH_MEMORY = N_NORMAL_MEMORY,
>
> N_CPU,
> NR_NODE_STATES
>};
>
>
>
>
>
>
>extern nodemask_t node_states[NR_NODE_STATES];
># 413 "include/linux/nodemask.h"
>static inline __attribute__((always_inline)) int node_state(int node, enum node_states state)
>{
> return node == 0;
>}
>
>static inline __attribute__((always_inline)) void node_set_state(int node, enum node_states state)
>{
>}
>
>static inline __attribute__((always_inline)) void node_clear_state(int node, enum node_states state)
>{
>}
>
>static inline __attribute__((always_inline)) int num_node_state(enum node_states state)
>{
> return 1;
>}
># 17 "include/linux/mmzone.h" 2
>
># 1 "include/linux/pageblock-flags.h" 1
># 33 "include/linux/pageblock-flags.h"
>enum pageblock_bits {
> PB_migrate, PB_migrate_end = (PB_migrate + 3) - 1,
> NR_PAGEBLOCK_BITS
>};
># 62 "include/linux/pageblock-flags.h"
>struct page;
>
>
>unsigned long get_pageblock_flags_group(struct page *page,
>     int start_bitidx, int end_bitidx);
>void set_pageblock_flags_group(struct page *page, unsigned long flags,
>     int start_bitidx, int end_bitidx);
># 18 "include/linux/mmzone.h" 2
>
># 1 "include/linux/bounds.h" 1
># 19 "include/linux/mmzone.h" 2
># 49 "include/linux/mmzone.h"
>extern int page_group_by_mobility_disabled;
>
>static inline __attribute__((always_inline)) int get_pageblock_migratetype(struct page *page)
>{
> if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
>  return 0;
>
> return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
>}
>
>struct free_area {
> struct list_head free_list[5];
> unsigned long nr_free;
>};
>
>struct pglist_data;
># 81 "include/linux/mmzone.h"
>enum zone_stat_item {
>
> NR_FREE_PAGES,
> NR_INACTIVE,
> NR_ACTIVE,
> NR_ANON_PAGES,
> NR_FILE_MAPPED,
>
> NR_FILE_PAGES,
> NR_FILE_DIRTY,
> NR_WRITEBACK,
>
> NR_SLAB_RECLAIMABLE,
> NR_SLAB_UNRECLAIMABLE,
> NR_PAGETABLE,
> NR_UNSTABLE_NFS,
> NR_BOUNCE,
> NR_VMSCAN_WRITE,
> NR_WRITEBACK_TEMP,
># 108 "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;
>
>
>
>
>
>
>
>} ;
># 136 "include/linux/mmzone.h"
>enum zone_type {
># 171 "include/linux/mmzone.h"
> ZONE_NORMAL,
># 183 "include/linux/mmzone.h"
> ZONE_MOVABLE,
> __MAX_NR_ZONES
>};
># 207 "include/linux/mmzone.h"
>struct zone {
>
> unsigned long pages_min, pages_low, pages_high;
># 218 "include/linux/mmzone.h"
> unsigned long lowmem_reserve[2];
># 229 "include/linux/mmzone.h"
> struct per_cpu_pageset pageset[1];
>
>
>
>
> spinlock_t lock;
>
>
>
>
> struct free_area free_area[11];
>
>
>
>
>
>
> unsigned long *pageblock_flags;
>
>
>
>
>
>
> 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 pages_scanned;
> unsigned long flags;
>
>
> atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
># 277 "include/linux/mmzone.h"
> int prev_priority;
># 307 "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;
># 328 "include/linux/mmzone.h"
> unsigned long spanned_pages;
> unsigned long present_pages;
>
>
>
>
> const char *name;
>} ;
>
>typedef enum {
> ZONE_ALL_UNRECLAIMABLE,
> ZONE_RECLAIM_LOCKED,
> ZONE_OOM_LOCKED,
>} zone_flags_t;
>
>static inline __attribute__((always_inline)) void zone_set_flag(struct zone *zone, zone_flags_t flag)
>{
> set_bit(flag, &zone->flags);
>}
>
>static inline __attribute__((always_inline)) int zone_test_and_set_flag(struct zone *zone, zone_flags_t flag)
>{
> return test_and_set_bit(flag, &zone->flags);
>}
>
>static inline __attribute__((always_inline)) void zone_clear_flag(struct zone *zone, zone_flags_t flag)
>{
> clear_bit(flag, &zone->flags);
>}
>
>static inline __attribute__((always_inline)) int zone_is_all_unreclaimable(const struct zone *zone)
>{
> return (__builtin_constant_p((ZONE_ALL_UNRECLAIMABLE)) ? constant_test_bit((ZONE_ALL_UNRECLAIMABLE), (&zone->flags)) : variable_test_bit((ZONE_ALL_UNRECLAIMABLE), (&zone->flags)));
>}
>
>static inline __attribute__((always_inline)) int zone_is_reclaim_locked(const struct zone *zone)
>{
> return (__builtin_constant_p((ZONE_RECLAIM_LOCKED)) ? constant_test_bit((ZONE_RECLAIM_LOCKED), (&zone->flags)) : variable_test_bit((ZONE_RECLAIM_LOCKED), (&zone->flags)));
>}
>
>static inline __attribute__((always_inline)) int zone_is_oom_locked(const struct zone *zone)
>{
> return (__builtin_constant_p((ZONE_OOM_LOCKED)) ? constant_test_bit((ZONE_OOM_LOCKED), (&zone->flags)) : variable_test_bit((ZONE_OOM_LOCKED), (&zone->flags)));
>}
># 461 "include/linux/mmzone.h"
>struct zonelist_cache;
>
>
>
>
>
>
>struct zoneref {
> struct zone *zone;
> int zone_idx;
>};
># 490 "include/linux/mmzone.h"
>struct zonelist {
> struct zonelist_cache *zlcache_ptr;
> struct zoneref _zonerefs[((1 << 0) * 2) + 1];
>
>
>
>};
># 508 "include/linux/mmzone.h"
>extern struct page *mem_map;
># 522 "include/linux/mmzone.h"
>struct bootmem_data;
>typedef struct pglist_data {
> struct zone node_zones[2];
> struct zonelist node_zonelists[1];
> int nr_zones;
>
> struct page *node_mem_map;
>
> struct bootmem_data *bdata;
># 541 "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;
># 560 "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
># 48 "include/linux/mutex.h"
>struct mutex {
>
> atomic_t count;
> spinlock_t wait_lock;
> struct list_head wait_list;
># 61 "include/linux/mutex.h"
>};
>
>
>
>
>
>struct mutex_waiter {
> struct list_head list;
> struct task_struct *task;
>
>
>
>
>};
># 106 "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;
>}
># 135 "include/linux/mutex.h"
>extern void mutex_lock(struct mutex *lock);
>extern int __attribute__((warn_unused_result)) mutex_lock_interruptible(struct mutex *lock);
>extern int __attribute__((warn_unused_result)) mutex_lock_killable(struct mutex *lock);
># 148 "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/rwsem.h" 1
># 17 "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;
>
>
>
>};
># 53 "include/linux/rwsem-spinlock.h"
>extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
>    struct lock_class_key *key);
># 63 "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);
>}
># 21 "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);
># 15 "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 *nh,
>  struct notifier_block *nb);
>extern int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
>  struct notifier_block *nb);
>extern int raw_notifier_chain_register(struct raw_notifier_head *nh,
>  struct notifier_block *nb);
>extern int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
>  struct notifier_block *nb);
>
>extern int blocking_notifier_chain_cond_register(
>  struct blocking_notifier_head *nh,
>  struct notifier_block *nb);
>
>extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
>  struct notifier_block *nb);
>extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
>  struct notifier_block *nb);
>extern int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
>  struct notifier_block *nb);
>extern int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
>  struct notifier_block *nb);
>
>extern int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
>  unsigned long val, void *v);
>extern int __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
> unsigned long val, void *v, int nr_to_call, int *nr_calls);
>extern int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
>  unsigned long val, void *v);
>extern int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
> unsigned long val, void *v, int nr_to_call, int *nr_calls);
>extern int raw_notifier_call_chain(struct raw_notifier_head *nh,
>  unsigned long val, void *v);
>extern int __raw_notifier_call_chain(struct raw_notifier_head *nh,
> unsigned long val, void *v, int nr_to_call, int *nr_calls);
>extern int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
>  unsigned long val, void *v);
>extern int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
> unsigned long val, void *v, int nr_to_call, int *nr_calls);
># 165 "include/linux/notifier.h"
>static inline __attribute__((always_inline)) int notifier_from_errno(int err)
>{
> return 0x8000 | (0x0001 - err);
>}
>
>
>static inline __attribute__((always_inline)) int notifier_to_errno(int ret)
>{
> ret &= ~0x8000;
> return ret > 0x0001 ? 0x0001 - ret : 0;
>}
># 247 "include/linux/notifier.h"
>extern struct blocking_notifier_head reboot_notifier_list;
># 7 "include/linux/memory_hotplug.h" 2
>
>struct page;
>struct zone;
>struct pglist_data;
>struct mem_section;
># 173 "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)) void register_page_bootmem_info_node(struct pglist_data *pgdat)
>{
>}
>
>
>
>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);
>extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms);
>extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
>       unsigned long pnum);
># 561 "include/linux/mmzone.h" 2
>
>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);
>enum memmap_context {
> MEMMAP_EARLY,
> MEMMAP_HOTPLUG,
>};
>extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
>         unsigned long size,
>         enum memmap_context context);
>
>
>
>
>static inline __attribute__((always_inline)) void memory_present(int nid, unsigned long start, unsigned long end) {}
># 591 "include/linux/mmzone.h"
>static inline __attribute__((always_inline)) int populated_zone(struct zone *zone)
>{
> return (!!zone->present_pages);
>}
>
>extern int movable_zone;
>
>static inline __attribute__((always_inline)) int zone_movable_is_highmem(void)
>{
>
>
>
> return 0;
>
>}
>
>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 0;
>
>}
>
>
>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[2 -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 *);
>
>extern int numa_zonelist_order_handler(struct ctl_table *, int,
>   struct file *, void *, size_t *, loff_t *);
>extern char numa_zonelist_order[];
>
>
>
># 1 "include/linux/topology.h" 1
># 30 "include/linux/topology.h"
>
># 1 "include/linux/cpumask.h" 1
># 92 "include/linux/cpumask.h"
>typedef struct { unsigned long bits[(((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))]; } 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);
>}
># 286 "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);
>}
>
>
>
>static inline __attribute__((always_inline)) void __cpus_onto(cpumask_t *dstp, const cpumask_t *origp,
>  const cpumask_t *relmapp, int nbits)
>{
> bitmap_onto(dstp->bits, origp->bits, relmapp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __cpus_fold(cpumask_t *dstp, const cpumask_t *origp,
>  int sz, int nbits)
>{
> bitmap_fold(dstp->bits, origp->bits, sz, nbits);
>}
># 412 "include/linux/cpumask.h"
>extern cpumask_t cpu_possible_map;
>extern cpumask_t cpu_online_map;
>extern cpumask_t cpu_present_map;
># 31 "include/linux/topology.h" 2
>
>
>
># 1 "include/linux/smp.h" 1
># 11 "include/linux/smp.h"
>extern void cpu_idle(void);
># 89 "include/linux/smp.h"
>static inline __attribute__((always_inline)) int up_smp_call_function(void (*func)(void *), void *info)
>{
> return 0;
>}
># 102 "include/linux/smp.h"
>static inline __attribute__((always_inline)) void smp_send_reschedule(int cpu) { }
># 144 "include/linux/smp.h"
>void smp_setup_processor_id(void);
># 34 "include/linux/topology.h" 2
>
># 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
># 52 "include/linux/topology.h"
>void arch_update_cpu_topology(void);
># 684 "include/linux/mmzone.h" 2
>
>
>
>
>
>
>
>extern struct pglist_data contig_page_data;
># 701 "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);
># 725 "include/linux/mmzone.h"
>static inline __attribute__((always_inline)) struct zone *zonelist_zone(struct zoneref *zoneref)
>{
> return zoneref->zone;
>}
>
>static inline __attribute__((always_inline)) int zonelist_zone_idx(struct zoneref *zoneref)
>{
> return zoneref->zone_idx;
>}
>
>static inline __attribute__((always_inline)) int zonelist_node_idx(struct zoneref *zoneref)
>{
>
>
>
>
> return 0;
>
>}
># 757 "include/linux/mmzone.h"
>struct zoneref *next_zones_zonelist(struct zoneref *z,
>     enum zone_type highest_zoneidx,
>     nodemask_t *nodes,
>     struct zone **zone);
># 775 "include/linux/mmzone.h"
>static inline __attribute__((always_inline)) struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
>     enum zone_type highest_zoneidx,
>     nodemask_t *nodes,
>     struct zone **zone)
>{
> return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
>        zone);
>}
># 818 "include/linux/mmzone.h"
>static inline __attribute__((always_inline)) unsigned long early_pfn_to_nid(unsigned long pfn)
>{
> return 0;
>}
># 990 "include/linux/mmzone.h"
>void memory_present(int nid, unsigned long start, unsigned long end);
>unsigned long __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) node_memmap_size_bytes(int, unsigned long, unsigned long);
># 5 "include/linux/gfp.h" 2
>
>
>
>struct vm_area_struct;
># 108 "include/linux/gfp.h"
>static inline __attribute__((always_inline)) int allocflags_to_migratetype(gfp_t gfp_flags)
>{
> ({ int __ret_warn_on = !!((gfp_flags & ((( gfp_t)0x80000u)|(( gfp_t)0x100000u))) == ((( gfp_t)0x80000u)|(( gfp_t)0x100000u))); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("include/linux/gfp.h", 110); __builtin_expect(!!(__ret_warn_on), 0); });
>
> if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
>  return 0;
>
>
> return (((gfp_flags & (( gfp_t)0x100000u)) != 0) << 1) |
>  ((gfp_flags & (( gfp_t)0x80000u)) != 0);
>}
>
>static inline __attribute__((always_inline)) enum zone_type gfp_zone(gfp_t flags)
>{
># 130 "include/linux/gfp.h"
> if ((flags & ((( gfp_t)0x02u) | (( gfp_t)0x100000u))) ==
>   ((( gfp_t)0x02u) | (( gfp_t)0x100000u)))
>  return ZONE_MOVABLE;
>
>
>
>
> return ZONE_NORMAL;
>}
># 147 "include/linux/gfp.h"
>static inline __attribute__((always_inline)) int gfp_zonelist(gfp_t flags)
>{
> if (0 && __builtin_expect(!!(flags & (( gfp_t)0x40000u)), 0))
>  return 1;
>
> return 0;
>}
># 164 "include/linux/gfp.h"
>static inline __attribute__((always_inline)) struct zonelist *node_zonelist(int nid, gfp_t flags)
>{
> return (&contig_page_data)->node_zonelists + gfp_zonelist(flags);
>}
>
>
>static inline __attribute__((always_inline)) void arch_free_page(struct page *page, int order) { }
>
>
>static inline __attribute__((always_inline)) void arch_alloc_page(struct page *page, int order) { }
>
>
>extern struct page *__alloc_pages(gfp_t, unsigned int, struct zonelist *);
>
>extern struct page *
>__alloc_pages_nodemask(gfp_t, unsigned int,
>    struct zonelist *, nodemask_t *nodemask);
>
>static inline __attribute__((always_inline)) struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
>      unsigned int order)
>{
> if (__builtin_expect(!!(order >= 11), 0))
>  return ((void *)0);
>
>
> if (nid < 0)
>  nid = (((void)(0),0));
>
> return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
>}
># 215 "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);
>void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
>void drain_all_pages(void);
>void drain_local_pages(void *dummy);
># 9 "include/linux/mm.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;
>}
># 12 "include/linux/mm.h" 2
>
># 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);
># 13 "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;
># 55 "include/linux/debug_locks.h"
>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_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)
>{
>}
># 14 "include/linux/mm.h" 2
>
># 1 "include/linux/mm_types.h" 1
>
>
>
>
># 1 "include/linux/auxvec.h" 1
>
>
>
>
># 1 "include/asm/auxvec.h" 1
># 5 "include/linux/auxvec.h" 2
># 5 "include/linux/mm_types.h" 2
># 13 "include/linux/mm_types.h"
># 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 int wait_for_completion_killable(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 *);
># 13 "include/linux/mm_types.h" 2
>
>
># 1 "include/asm/mmu.h" 1
># 9 "include/asm/mmu.h"
>
># 1 "arch/um/include/um_mmu.h" 1
># 9 "arch/um/include/um_mmu.h"
>
># 1 "arch/um/include/uml-config.h" 1
># 10 "arch/um/include/um_mmu.h" 2
>
># 1 "/home/low/dev/linux-2.6-low/arch/um/include/skas/mm_id.h" 1
># 9 "/home/low/dev/linux-2.6-low/arch/um/include/skas/mm_id.h"
>struct mm_id {
> union {
>  int mm_fd;
>  int pid;
> } u;
> unsigned long stack;
>};
># 11 "arch/um/include/um_mmu.h" 2
>
># 1 "include/asm/ldt.h" 1
># 14 "include/asm/ldt.h"
>extern void ldt_host_info(void);
># 23 "include/asm/ldt.h"
>struct ldt_entry {
> __u32 a;
> __u32 b;
>};
>
>typedef struct uml_ldt {
> int entry_count;
> struct mutex lock;
> union {
>  struct ldt_entry * pages[((8192 * 8)/((1UL) << 12))];
>  struct ldt_entry entries[((((8192 * 8)/((1UL) << 12))*sizeof(void *))/8)];
> } u;
>} uml_ldt_t;
># 12 "arch/um/include/um_mmu.h" 2
>
>typedef struct mm_context {
> struct mm_id id;
> struct uml_ldt ldt;
> struct page **stub_pages;
>} mm_context_t;
>
>extern void __switch_mm(struct mm_id * mm_idp);
>
>
>extern long init_new_ldt(struct mm_context *to_mm, struct mm_context *from_mm);
>extern void free_ldt(struct mm_context *mm);
># 10 "include/asm/mmu.h" 2
># 15 "include/linux/mm_types.h" 2
>
>
>
>
>
>
>struct address_space;
>
>
>
>
>typedef unsigned long mm_counter_t;
># 36 "include/linux/mm_types.h"
>struct page {
> unsigned long flags;
>
> atomic_t _count;
> union {
>  atomic_t _mapcount;
>
>
>
>  struct {
>   u16 inuse;
>   u16 objects;
>  };
> };
> union {
>     struct {
>  unsigned long private;
>
>
>
>
>
>
>  struct address_space *mapping;
>
>
>
>
>
>
>     };
>
>
>
>     struct kmem_cache *slab;
>     struct page *first_page;
> };
> union {
>  unsigned long index;
>  void *freelist;
> };
> struct list_head lru;
># 97 "include/linux/mm_types.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;
>
>
>
>
>
>
>
>};
>
>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;
> int core_waiters;
> 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[(2*(1 + (14 + 2) + 1))];
>
> cpumask_t cpu_vm_mask;
>
>
> mm_context_t context;
># 216 "include/linux/mm_types.h"
> unsigned int faultstamp;
> unsigned int token_priority;
> unsigned int last_interval;
>
> unsigned long flags;
>
>
> struct completion *core_startup_done, core_done;
>
>
> rwlock_t ioctx_list_lock;
> struct kioctx *ioctx_list;
># 244 "include/linux/mm_types.h"
> struct file *exe_file;
> unsigned long num_exe_file_vmas;
>
>};
># 15 "include/linux/mm.h" 2
>
>struct mempolicy;
>struct anon_vma;
>struct file_ra_state;
>struct user_struct;
>struct writeback_control;
>
>
>extern unsigned long max_mapnr;
>
>
>extern unsigned long num_physpages;
>extern void * high_memory;
>extern int page_cluster;
>
>
>extern int sysctl_legacy_va_layout;
>
>
>
>
>extern unsigned long mmap_min_addr;
>
>
>
># 1 "include/asm/pgtable.h" 1
># 26 "include/asm/pgtable.h"
>
># 1 "include/asm/pgtable-3level.h" 1
># 10 "include/asm/pgtable-3level.h"
>
># 1 "include/asm-generic/pgtable-nopud.h" 1
># 13 "include/asm-generic/pgtable-nopud.h"
>typedef struct { pgd_t pgd; } pud_t;
># 25 "include/asm-generic/pgtable-nopud.h"
>static inline __attribute__((always_inline)) int pgd_none(pgd_t pgd) { return 0; }
>static inline __attribute__((always_inline)) int pgd_bad(pgd_t pgd) { return 0; }
>static inline __attribute__((always_inline)) int pgd_present(pgd_t pgd) { return 1; }
>static inline __attribute__((always_inline)) void pgd_clear(pgd_t *pgd) { }
># 38 "include/asm-generic/pgtable-nopud.h"
>static inline __attribute__((always_inline)) pud_t * pud_offset(pgd_t * pgd, unsigned long address)
>{
> return (pud_t *)pgd;
>}
># 11 "include/asm/pgtable-3level.h" 2
># 68 "include/asm/pgtable-3level.h"
>static inline __attribute__((always_inline)) int pgd_newpage(pgd_t pgd)
>{
> return(((pgd).pgd) & 0x002);
>}
>
>static inline __attribute__((always_inline)) void pgd_mkuptodate(pgd_t pgd) { ((pgd).pgd) &= ~0x002; }
>
>
>
>
>
>
>
>struct mm_struct;
>extern pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address);
>
>static inline __attribute__((always_inline)) void pud_clear (pud_t *pud)
>{
> set_64bit((phys_t *) (pud), ((((((pud_t) { ((pgd_t) { (0x002) } ) } )).pgd).pgd)));
>}
># 96 "include/asm/pgtable-3level.h"
>static inline __attribute__((always_inline)) unsigned long pte_pfn(pte_t pte)
>{
> return ((pfn_t) ((((pte).pte)) >> 12));
>}
>
>static inline __attribute__((always_inline)) pte_t pfn_pte(pfn_t page_nr, pgprot_t pgprot)
>{
> pte_t pte;
> phys_t phys = ((phys_t) ((page_nr) << 12));
>
> (pte).pte = (phys | ((pgprot).pgprot));
> return pte;
>}
>
>static inline __attribute__((always_inline)) pmd_t pfn_pmd(pfn_t page_nr, pgprot_t pgprot)
>{
> return ((pmd_t) { ((page_nr << 12) | ((pgprot).pgprot)) } );
>}
># 27 "include/asm/pgtable.h" 2
>
>
>
>
>extern pgd_t swapper_pg_dir[512];
>
>
>extern unsigned long *empty_zero_page;
># 46 "include/asm/pgtable.h"
>extern unsigned long end_iomem;
># 122 "include/asm/pgtable.h"
>static inline __attribute__((always_inline)) int pte_none(pte_t pte)
>{
> return (!((pte).pte & ~0x002));
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int pte_read(pte_t pte)
>{
> return((((pte).pte & (0x040))) &&
>        !(((pte).pte & (0x010))));
>}
>
>static inline __attribute__((always_inline)) int pte_exec(pte_t pte){
> return((((pte).pte & (0x040))) &&
>        !(((pte).pte & (0x010))));
>}
>
>static inline __attribute__((always_inline)) int pte_write(pte_t pte)
>{
> return((((pte).pte & (0x020))) &&
>        !(((pte).pte & (0x010))));
>}
>
>
>
>
>static inline __attribute__((always_inline)) int pte_file(pte_t pte)
>{
> return ((pte).pte & (0x008));
>}
>
>static inline __attribute__((always_inline)) int pte_dirty(pte_t pte)
>{
> return ((pte).pte & (0x100));
>}
>
>static inline __attribute__((always_inline)) int pte_young(pte_t pte)
>{
> return ((pte).pte & (0x080));
>}
>
>static inline __attribute__((always_inline)) int pte_newpage(pte_t pte)
>{
> return ((pte).pte & (0x002));
>}
>
>static inline __attribute__((always_inline)) int pte_newprot(pte_t pte)
>{
> return(((pte).pte & ((0x001 | 0x010))) && (((pte).pte & (0x004))));
>}
>
>static inline __attribute__((always_inline)) int pte_special(pte_t pte)
>{
> return 0;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) pte_t pte_mknewprot(pte_t pte)
>{
> ((pte).pte |= (0x004));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkclean(pte_t pte)
>{
> ((pte).pte &= ~(0x100));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkold(pte_t pte)
>{
> ((pte).pte &= ~(0x080));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_wrprotect(pte_t pte)
>{
> ((pte).pte &= ~(0x020));
> return(pte_mknewprot(pte));
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkread(pte_t pte)
>{
> ((pte).pte |= (0x040));
> return(pte_mknewprot(pte));
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkdirty(pte_t pte)
>{
> ((pte).pte |= (0x100));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkyoung(pte_t pte)
>{
> ((pte).pte |= (0x080));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkwrite(pte_t pte)
>{
> ((pte).pte |= (0x020));
> return(pte_mknewprot(pte));
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkuptodate(pte_t pte)
>{
> ((pte).pte &= ~(0x002));
> if(((pte).pte & ((0x001 | 0x010))))
>  ((pte).pte &= ~(0x004));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mknewpage(pte_t pte)
>{
> ((pte).pte |= (0x002));
> return(pte);
>}
>
>static inline __attribute__((always_inline)) pte_t pte_mkspecial(pte_t pte)
>{
> return(pte);
>}
>
>static inline __attribute__((always_inline)) void set_pte(pte_t *pteptr, pte_t pteval)
>{
> ((*pteptr).pte = (pteval).pte);
>
>
>
>
>
>
> *pteptr = pte_mknewpage(*pteptr);
> if(((*pteptr).pte & ((0x001 | 0x010)))) *pteptr = pte_mknewprot(*pteptr);
>}
># 286 "include/asm/pgtable.h"
>static inline __attribute__((always_inline)) pte_t pte_modify(pte_t pte, pgprot_t newprot)
>{
> (pte).pte = ((((pte).pte) & ((~(((1UL) << 12)-1)) | 0x080 | 0x100)) | ((newprot).pgprot));
> return pte;
>}
># 339 "include/asm/pgtable.h"
>struct mm_struct;
>extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr);
># 356 "include/asm/pgtable.h"
>
># 1 "include/asm-generic/pgtable.h" 1
># 94 "include/asm-generic/pgtable.h"
>struct mm_struct;
>static inline __attribute__((always_inline)) void ptep_set_wrprotect(struct mm_struct *mm, unsigned long address, pte_t *ptep)
>{
> pte_t old_pte = *ptep;
> set_pte(ptep,pte_wrprotect(old_pte));
>}
># 162 "include/asm-generic/pgtable.h"
>void pgd_clear_bad(pgd_t *);
>void pud_clear_bad(pud_t *);
>void pmd_clear_bad(pmd_t *);
>
>static inline __attribute__((always_inline)) int pgd_none_or_clear_bad(pgd_t *pgd)
>{
> if (pgd_none(*pgd))
>  return 1;
> if (__builtin_expect(!!(pgd_bad(*pgd)), 0)) {
>  pgd_clear_bad(pgd);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((always_inline)) int pud_none_or_clear_bad(pud_t *pud)
>{
> if ((!(((((*pud).pgd).pgd)) & ~0x002)))
>  return 1;
> if (__builtin_expect(!!(((((((*pud).pgd).pgd)) & (~(~(((1UL) << 12)-1)) & ~0x040)) != (0x001 | 0x020 | 0x080 | 0x100))), 0)) {
>  pud_clear_bad(pud);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((always_inline)) int pmd_none_or_clear_bad(pmd_t *pmd)
>{
> if ((!((unsigned long)((*pmd).pmd) & ~0x002)))
>  return 1;
> if (__builtin_expect(!!(((((*pmd).pmd) & (~(~(((1UL) << 12)-1)) & ~0x040)) != (0x001 | 0x020 | 0x080 | 0x100))), 0)) {
>  pmd_clear_bad(pmd);
>  return 1;
> }
> return 0;
>}
># 357 "include/asm/pgtable.h" 2
># 40 "include/linux/mm.h" 2
># 53 "include/linux/mm.h"
>extern struct kmem_cache *vm_area_cachep;
>
>
>
>
>
>
>struct vm_list_struct {
> struct vm_list_struct *next;
> struct vm_area_struct *vma;
>};
># 132 "include/linux/mm.h"
>extern pgprot_t protection_map[16];
># 147 "include/linux/mm.h"
>struct vm_fault {
> unsigned int flags;
> unsigned long pgoff;
> void *virtual_address;
>
> struct page *page;
>
>
>
>
>};
>
>
>
>
>
>
>struct vm_operations_struct {
> void (*open)(struct vm_area_struct * area);
> void (*close)(struct vm_area_struct * area);
> int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);
> unsigned long (*nopfn)(struct vm_area_struct *area,
>   unsigned long address);
>
>
>
> int (*page_mkwrite)(struct vm_area_struct *vma, struct page *page);
># 199 "include/linux/mm.h"
>};
>
>struct mmu_gather;
>struct inode;
># 211 "include/linux/mm.h"
>
># 1 "include/linux/page-flags.h" 1
># 72 "include/linux/page-flags.h"
>enum pageflags {
> PG_locked,
> PG_error,
> PG_referenced,
> PG_uptodate,
> PG_dirty,
> PG_lru,
> PG_active,
> PG_slab,
> PG_owner_priv_1,
> PG_arch_1,
> PG_reserved,
> PG_private,
> PG_writeback,
>
> PG_head,
> PG_tail,
>
>
>
> PG_swapcache,
> PG_mappedtodisk,
> PG_reclaim,
> PG_buddy,
>
>
>
> __NR_PAGEFLAGS
>};
># 149 "include/linux/page-flags.h"
>struct page;
>
>static inline __attribute__((always_inline)) int PageLocked(struct page *page) { return (__builtin_constant_p((PG_locked)) ? constant_test_bit((PG_locked), (&page->flags)) : variable_test_bit((PG_locked), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageLocked(struct page *page) { set_bit(PG_locked, &page->flags); } static inline __attribute__((always_inline)) void ClearPageLocked(struct page *page) { clear_bit(PG_locked, &page->flags); } static inline __attribute__((always_inline)) int TestSetPageLocked(struct page *page) { return test_and_set_bit(PG_locked, &page->flags); } static inline __attribute__((always_inline)) int TestClearPageLocked(struct page *page) { return test_and_clear_bit(PG_locked, &page->flags); }
>static inline __attribute__((always_inline)) int PageError(struct page *page) { return (__builtin_constant_p((PG_error)) ? constant_test_bit((PG_error), (&page->flags)) : variable_test_bit((PG_error), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageError(struct page *page) { set_bit(PG_error, &page->flags); } static inline __attribute__((always_inline)) void ClearPageError(struct page *page) { clear_bit(PG_error, &page->flags); }
>static inline __attribute__((always_inline)) int PageReferenced(struct page *page) { return (__builtin_constant_p((PG_referenced)) ? constant_test_bit((PG_referenced), (&page->flags)) : variable_test_bit((PG_referenced), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageReferenced(struct page *page) { set_bit(PG_referenced, &page->flags); } static inline __attribute__((always_inline)) void ClearPageReferenced(struct page *page) { clear_bit(PG_referenced, &page->flags); } static inline __attribute__((always_inline)) int TestClearPageReferenced(struct page *page) { return test_and_clear_bit(PG_referenced, &page->flags); }
>static inline __attribute__((always_inline)) int PageDirty(struct page *page) { return (__builtin_constant_p((PG_dirty)) ? constant_test_bit((PG_dirty), (&page->flags)) : variable_test_bit((PG_dirty), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageDirty(struct page *page) { set_bit(PG_dirty, &page->flags); } static inline __attribute__((always_inline)) void ClearPageDirty(struct page *page) { clear_bit(PG_dirty, &page->flags); } static inline __attribute__((always_inline)) int TestSetPageDirty(struct page *page) { return test_and_set_bit(PG_dirty, &page->flags); } static inline __attribute__((always_inline)) int TestClearPageDirty(struct page *page) { return test_and_clear_bit(PG_dirty, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageDirty(struct page *page) { __clear_bit(PG_dirty, &page->flags); }
>static inline __attribute__((always_inline)) int PageLRU(struct page *page) { return (__builtin_constant_p((PG_lru)) ? constant_test_bit((PG_lru), (&page->flags)) : variable_test_bit((PG_lru), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageLRU(struct page *page) { set_bit(PG_lru, &page->flags); } static inline __attribute__((always_inline)) void ClearPageLRU(struct page *page) { clear_bit(PG_lru, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageLRU(struct page *page) { __clear_bit(PG_lru, &page->flags); }
>static inline __attribute__((always_inline)) int PageActive(struct page *page) { return (__builtin_constant_p((PG_active)) ? constant_test_bit((PG_active), (&page->flags)) : variable_test_bit((PG_active), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageActive(struct page *page) { set_bit(PG_active, &page->flags); } static inline __attribute__((always_inline)) void ClearPageActive(struct page *page) { clear_bit(PG_active, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageActive(struct page *page) { __clear_bit(PG_active, &page->flags); }
>static inline __attribute__((always_inline)) int PageSlab(struct page *page) { return (__builtin_constant_p((PG_slab)) ? constant_test_bit((PG_slab), (&page->flags)) : variable_test_bit((PG_slab), (&page->flags))); } static inline __attribute__((always_inline)) void __SetPageSlab(struct page *page) { __set_bit(PG_slab, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageSlab(struct page *page) { __clear_bit(PG_slab, &page->flags); }
>static inline __attribute__((always_inline)) int PageChecked(struct page *page) { return (__builtin_constant_p((PG_owner_priv_1)) ? constant_test_bit((PG_owner_priv_1), (&page->flags)) : variable_test_bit((PG_owner_priv_1), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageChecked(struct page *page) { set_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) void ClearPageChecked(struct page *page) { clear_bit(PG_owner_priv_1, &page->flags); }
>static inline __attribute__((always_inline)) int PagePinned(struct page *page) { return (__builtin_constant_p((PG_owner_priv_1)) ? constant_test_bit((PG_owner_priv_1), (&page->flags)) : variable_test_bit((PG_owner_priv_1), (&page->flags))); } static inline __attribute__((always_inline)) void SetPagePinned(struct page *page) { set_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) void ClearPagePinned(struct page *page) { clear_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) int TestSetPagePinned(struct page *page) { return test_and_set_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) int TestClearPagePinned(struct page *page) { return test_and_clear_bit(PG_owner_priv_1, &page->flags); }
>static inline __attribute__((always_inline)) int PageReserved(struct page *page) { return (__builtin_constant_p((PG_reserved)) ? constant_test_bit((PG_reserved), (&page->flags)) : variable_test_bit((PG_reserved), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageReserved(struct page *page) { set_bit(PG_reserved, &page->flags); } static inline __attribute__((always_inline)) void ClearPageReserved(struct page *page) { clear_bit(PG_reserved, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageReserved(struct page *page) { __clear_bit(PG_reserved, &page->flags); }
>static inline __attribute__((always_inline)) int PagePrivate(struct page *page) { return (__builtin_constant_p((PG_private)) ? constant_test_bit((PG_private), (&page->flags)) : variable_test_bit((PG_private), (&page->flags))); } static inline __attribute__((always_inline)) void SetPagePrivate(struct page *page) { set_bit(PG_private, &page->flags); } static inline __attribute__((always_inline)) void ClearPagePrivate(struct page *page) { clear_bit(PG_private, &page->flags); } static inline __attribute__((always_inline)) void __ClearPagePrivate(struct page *page) { __clear_bit(PG_private, &page->flags); }
> static inline __attribute__((always_inline)) void __SetPagePrivate(struct page *page) { __set_bit(PG_private, &page->flags); }
>
>
>
>
>
>static inline __attribute__((always_inline)) int PageWriteback(struct page *page) { return (__builtin_constant_p((PG_writeback)) ? constant_test_bit((PG_writeback), (&page->flags)) : variable_test_bit((PG_writeback), (&page->flags))); } static inline __attribute__((always_inline)) int TestSetPageWriteback(struct page *page) { return test_and_set_bit(PG_writeback, &page->flags); } static inline __attribute__((always_inline)) int TestClearPageWriteback(struct page *page) { return test_and_clear_bit(PG_writeback, &page->flags); }
>static inline __attribute__((always_inline)) int PageBuddy(struct page *page) { return (__builtin_constant_p((PG_buddy)) ? constant_test_bit((PG_buddy), (&page->flags)) : variable_test_bit((PG_buddy), (&page->flags))); } static inline __attribute__((always_inline)) void __SetPageBuddy(struct page *page) { __set_bit(PG_buddy, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageBuddy(struct page *page) { __clear_bit(PG_buddy, &page->flags); }
>static inline __attribute__((always_inline)) int PageMappedToDisk(struct page *page) { return (__builtin_constant_p((PG_mappedtodisk)) ? constant_test_bit((PG_mappedtodisk), (&page->flags)) : variable_test_bit((PG_mappedtodisk), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageMappedToDisk(struct page *page) { set_bit(PG_mappedtodisk, &page->flags); } static inline __attribute__((always_inline)) void ClearPageMappedToDisk(struct page *page) { clear_bit(PG_mappedtodisk, &page->flags); }
>
>
>static inline __attribute__((always_inline)) int PageReclaim(struct page *page) { return (__builtin_constant_p((PG_reclaim)) ? constant_test_bit((PG_reclaim), (&page->flags)) : variable_test_bit((PG_reclaim), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageReclaim(struct page *page) { set_bit(PG_reclaim, &page->flags); } static inline __attribute__((always_inline)) void ClearPageReclaim(struct page *page) { clear_bit(PG_reclaim, &page->flags); } static inline __attribute__((always_inline)) int TestClearPageReclaim(struct page *page) { return test_and_clear_bit(PG_reclaim, &page->flags); }
>static inline __attribute__((always_inline)) int PageReadahead(struct page *page) { return (__builtin_constant_p((PG_reclaim)) ? constant_test_bit((PG_reclaim), (&page->flags)) : variable_test_bit((PG_reclaim), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageReadahead(struct page *page) { set_bit(PG_reclaim, &page->flags); } static inline __attribute__((always_inline)) void ClearPageReadahead(struct page *page) { clear_bit(PG_reclaim, &page->flags); }
># 183 "include/linux/page-flags.h"
>static inline __attribute__((always_inline)) int PageHighMem(struct page *page) { return 0; }
>
>
>
>static inline __attribute__((always_inline)) int PageSwapCache(struct page *page) { return (__builtin_constant_p((PG_swapcache)) ? constant_test_bit((PG_swapcache), (&page->flags)) : variable_test_bit((PG_swapcache), (&page->flags))); } static inline __attribute__((always_inline)) void SetPageSwapCache(struct page *page) { set_bit(PG_swapcache, &page->flags); } static inline __attribute__((always_inline)) void ClearPageSwapCache(struct page *page) { clear_bit(PG_swapcache, &page->flags); }
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int PageUncached(struct page *page) { return 0; }
>
>
>static inline __attribute__((always_inline)) int PageUptodate(struct page *page)
>{
> int ret = (__builtin_constant_p((PG_uptodate)) ? constant_test_bit((PG_uptodate), (&(page)->flags)) : variable_test_bit((PG_uptodate), (&(page)->flags)));
># 210 "include/linux/page-flags.h"
> if (ret)
>  __asm__ __volatile__("": : :"memory");
>
> return ret;
>}
>
>static inline __attribute__((always_inline)) void __SetPageUptodate(struct page *page)
>{
> __asm__ __volatile__("": : :"memory");
> __set_bit(PG_uptodate, &(page)->flags);
>
>
>
>}
>
>static inline __attribute__((always_inline)) void SetPageUptodate(struct page *page)
>{
># 239 "include/linux/page-flags.h"
> __asm__ __volatile__("": : :"memory");
> set_bit(PG_uptodate, &(page)->flags);
>
>}
>
>static inline __attribute__((always_inline)) void ClearPageUptodate(struct page *page) { clear_bit(PG_uptodate, &page->flags); }
>
>extern void cancel_dirty_page(struct page *page, unsigned int account_size);
>
>int test_clear_page_writeback(struct page *page);
>int test_set_page_writeback(struct page *page);
>
>static inline __attribute__((always_inline)) void set_page_writeback(struct page *page)
>{
> test_set_page_writeback(page);
>}
># 263 "include/linux/page-flags.h"
>static inline __attribute__((always_inline)) int PageHead(struct page *page) { return (__builtin_constant_p((PG_head)) ? constant_test_bit((PG_head), (&page->flags)) : variable_test_bit((PG_head), (&page->flags))); } static inline __attribute__((always_inline)) void __SetPageHead(struct page *page) { __set_bit(PG_head, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageHead(struct page *page) { __clear_bit(PG_head, &page->flags); }
>static inline __attribute__((always_inline)) int PageTail(struct page *page) { return (__builtin_constant_p((PG_tail)) ? constant_test_bit((PG_tail), (&page->flags)) : variable_test_bit((PG_tail), (&page->flags))); } static inline __attribute__((always_inline)) void __SetPageTail(struct page *page) { __set_bit(PG_tail, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageTail(struct page *page) { __clear_bit(PG_tail, &page->flags); }
>
>static inline __attribute__((always_inline)) int PageCompound(struct page *page)
>{
> return page->flags & ((1L << PG_head) | (1L << PG_tail));
>
>}
># 212 "include/linux/mm.h" 2
># 235 "include/linux/mm.h"
>static inline __attribute__((always_inline)) int put_page_testzero(struct page *page)
>{
> do { } while(0);
> return atomic_dec_and_test(&page->_count);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int get_page_unless_zero(struct page *page)
>{
> do { } while(0);
> return atomic_add_unless((&page->_count), 1, 0);
>}
>
>
>struct page *vmalloc_to_page(const void *addr);
>unsigned long vmalloc_to_pfn(const void *addr);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int is_vmalloc_addr(const void *x)
>{
>
> unsigned long addr = (unsigned long)x;
>
> return addr >= ((end_iomem + ((8*1024*1024))) & ~(((8*1024*1024))-1)) && addr < ((((task_size) - 2 * ((1UL) << 12)) - (__end_of_fixed_addresses << 12))-2*((1UL) << 12));
>
>
>
>}
>
>static inline __attribute__((always_inline)) struct page *compound_head(struct page *page)
>{
> if (__builtin_expect(!!(PageTail(page)), 0))
>  return page->first_page;
> return page;
>}
>
>static inline __attribute__((always_inline)) int page_count(struct page *page)
>{
> return ((&compound_head(page)->_count)->counter);
>}
>
>static inline __attribute__((always_inline)) void get_page(struct page *page)
>{
> page = compound_head(page);
> do { } while(0);
> atomic_inc(&page->_count);
>}
>
>static inline __attribute__((always_inline)) struct page *virt_to_head_page(const void *x)
>{
> struct page *page = (mem_map + ((((pfn_t) ((to_phys((void *) (unsigned long) ((const unsigned long) x))) >> 12))) - (0UL)));
> return compound_head(page);
>}
>
>
>
>
>
>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);
>
>
>
>
>
>
>typedef void compound_page_dtor(struct page *);
>
>static inline __attribute__((always_inline)) void set_compound_page_dtor(struct page *page,
>      compound_page_dtor *dtor)
>{
> page[1].lru.next = (void *)dtor;
>}
>
>static inline __attribute__((always_inline)) compound_page_dtor *get_compound_page_dtor(struct page *page)
>{
> return (compound_page_dtor *)page[1].lru.next;
>}
>
>static inline __attribute__((always_inline)) int compound_order(struct page *page)
>{
> if (!PageHead(page))
>  return 0;
> return (unsigned long)page[1].lru.prev;
>}
>
>static inline __attribute__((always_inline)) void set_compound_order(struct page *page, unsigned long order)
>{
> page[1].lru.prev = (void *)order;
>}
># 486 "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);
>}
># 499 "include/linux/mm.h"
>static inline __attribute__((always_inline)) int page_zone_id(struct page *page)
>{
> return (page->flags >> ((((((sizeof(unsigned long)*8) - 0) - 0) < ((((sizeof(unsigned long)*8) - 0) - 0) - 1))? (((sizeof(unsigned long)*8) - 0) - 0) : ((((sizeof(unsigned long)*8) - 0) - 0) - 1)) * ((0 + 1) != 0))) & ((1UL << (0 + 1)) - 1);
>}
>
>static inline __attribute__((always_inline)) int zone_to_nid(struct zone *zone)
>{
>
>
>
> return 0;
>
>}
>
>
>
>
>static inline __attribute__((always_inline)) int page_to_nid(struct page *page)
>{
> return (page->flags >> ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0))) & ((1UL << 0) - 1);
>}
>
>
>static inline __attribute__((always_inline)) struct zone *page_zone(struct page *page)
>{
> return &(&contig_page_data)->node_zones[page_zonenum(page)];
>}
># 534 "include/linux/mm.h"
>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));
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long round_hint_to_min(unsigned long hint)
>{
>
>
>
>
>
>
> return hint;
>}
>
>
>
>
>
># 1 "include/linux/vmstat.h" 1
>
>
>
>
>
># 1 "include/linux/percpu.h" 1
>
>
>
>
>
># 1 "include/linux/slab.h" 1
># 56 "include/linux/slab.h"
>void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) kmem_cache_init(void);
>int slab_is_available(void);
>
>struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
>   unsigned long,
>   void (*)(struct kmem_cache *, void *));
>void kmem_cache_destroy(struct kmem_cache *);
>int kmem_cache_shrink(struct kmem_cache *);
>void kmem_cache_free(struct kmem_cache *, void *);
>unsigned int kmem_cache_size(struct kmem_cache *);
>const char *kmem_cache_name(struct kmem_cache *);
>int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
># 99 "include/linux/slab.h"
>void * __attribute__((warn_unused_result)) krealloc(const void *, size_t, gfp_t);
>void kfree(const void *);
>size_t ksize(const void *);
># 127 "include/linux/slab.h"
>
># 1 "include/linux/slab_def.h" 1
># 19 "include/linux/slab_def.h"
>struct cache_sizes {
> size_t cs_size;
> struct kmem_cache *cs_cachep;
>
>
>
>};
>extern struct cache_sizes malloc_sizes[];
>
>void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
>void *__kmalloc(size_t size, gfp_t flags);
>
>static inline __attribute__((always_inline)) void *kmalloc(size_t size, gfp_t flags)
>{
> if (__builtin_constant_p(size)) {
>  int i = 0;
>
>  if (!size)
>   return ((void *)16);
>
>
>
>
>
>
>
># 1 "include/linux/kmalloc_sizes.h" 1
>
> if (size <= 32) goto found; else i++;
>
> if (size <= 64) goto found; else i++;
>
>
>
> if (size <= 128) goto found; else i++;
>
> if (size <= 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++;
># 45 "include/linux/slab_def.h" 2
>
>  {
>   extern void __you_cannot_kmalloc_that_much(void);
>   __you_cannot_kmalloc_that_much();
>  }
>found:
>
>
>
>
>
>  return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
> }
> return __kmalloc(size, flags);
>}
># 128 "include/linux/slab.h" 2
># 181 "include/linux/slab.h"
>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 __kmalloc(n * size, flags | (( gfp_t)0x8000u));
>}
># 199 "include/linux/slab.h"
>static inline __attribute__((always_inline)) void *kmalloc_node(size_t size, gfp_t flags, int node)
>{
> return kmalloc(size, flags);
>}
>
>static inline __attribute__((always_inline)) void *__kmalloc_node(size_t size, gfp_t flags, int node)
>{
> return __kmalloc(size, flags);
>}
>
>void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
>
>static inline __attribute__((always_inline)) void *kmem_cache_alloc_node(struct kmem_cache *cachep,
>     gfp_t flags, int node)
>{
> return kmem_cache_alloc(cachep, flags);
>}
># 264 "include/linux/slab.h"
>static inline __attribute__((always_inline)) void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
>{
> return kmem_cache_alloc(k, flags | (( gfp_t)0x8000u));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void *kzalloc(size_t size, gfp_t flags)
>{
> return kmalloc(size, flags | (( gfp_t)0x8000u));
>}
>
>
>extern const struct seq_operations slabinfo_op;
>ssize_t slabinfo_write(struct file *, const char *, size_t, loff_t *);
># 6 "include/linux/percpu.h" 2
>
>
>
>
># 1 "include/asm/percpu.h" 1
>
>
>
>
># 1 "include/asm/arch/percpu.h" 1
># 79 "include/asm/arch/percpu.h"
>
># 1 "include/asm-generic/percpu.h" 1
># 80 "include/asm/arch/percpu.h" 2
>
>
>extern __typeof__(unsigned long) per_cpu__this_cpu_off;
>
>
>
>extern void __bad_percpu_size(void);
># 5 "include/asm/percpu.h" 2
># 10 "include/linux/percpu.h" 2
># 89 "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);
>}
># 6 "include/linux/vmstat.h" 2
>
># 1 "include/linux/mm.h" 1
># 7 "include/linux/vmstat.h" 2
># 31 "include/linux/vmstat.h"
>enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
>  PGALLOC_NORMAL , PGALLOC_MOVABLE,
>  PGFREE, PGACTIVATE, PGDEACTIVATE,
>  PGFAULT, PGMAJFAULT,
>  PGREFILL_NORMAL , PGREFILL_MOVABLE,
>  PGSTEAL_NORMAL , PGSTEAL_MOVABLE,
>  PGSCAN_KSWAPD_NORMAL , PGSCAN_KSWAPD_MOVABLE,
>  PGSCAN_DIRECT_NORMAL , PGSCAN_DIRECT_MOVABLE,
>  PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
>  PAGEOUTRUN, ALLOCSTALL, PGROTATED,
>
>
>
>  NR_VM_EVENT_ITEMS
>};
># 58 "include/linux/vmstat.h"
>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);
># 126 "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;
>}
># 198 "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);
># 226 "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_state(struct zone *zone, enum zone_stat_item item)
>{
> atomic_long_dec(&zone->vm_stat[item]);
> atomic_long_dec(&vm_stat[item]);
>}
>
>static inline __attribute__((always_inline)) void __dec_zone_page_state(struct page *page,
>   enum zone_stat_item item)
>{
> __dec_zone_state(page_zone(page), item);
>}
># 264 "include/linux/vmstat.h"
>static inline __attribute__((always_inline)) void refresh_cpu_vm_stats(int cpu) { }
># 579 "include/linux/mm.h" 2
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) void *lowmem_page_address(struct page *page)
>{
> return to_virt((unsigned long) (((unsigned long)((page) - mem_map) + (0UL)) << 12));
>}
># 621 "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;
>
> do { } while(0);
>
> if (__builtin_expect(!!(PageSwapCache(page)), 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(!!(PageSwapCache(page)), 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;
>}
># 703 "include/linux/mm.h"
>extern void show_free_areas(void);
>
>
>int shmem_lock(struct file *file, int lock, struct user_struct *user);
>
>
>
>
>
>
>
>struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
>
>int shmem_zero_setup(struct vm_area_struct *);
># 726 "include/linux/mm.h"
>extern int can_do_mlock(void);
>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 *vma, unsigned long addr,
>  pte_t pte);
>
>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 *);
># 762 "include/linux/mm.h"
>struct mm_walk {
> int (*pgd_entry)(pgd_t *, unsigned long, unsigned long, void *);
> int (*pud_entry)(pud_t *, unsigned long, unsigned long, void *);
> int (*pmd_entry)(pmd_t *, unsigned long, unsigned long, void *);
> int (*pte_entry)(pte_t *, unsigned long, unsigned long, void *);
> int (*pte_hole)(unsigned long, unsigned long, void *);
>};
>
>int walk_page_range(const struct mm_struct *, unsigned long addr,
>      unsigned long end, const struct mm_walk *walk,
>      void *private);
>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);
>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 handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
>   unsigned long address, int write_access);
># 805 "include/linux/mm.h"
>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);
>
>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 __set_page_dirty_no_writeback(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 move_page_tables(struct vm_area_struct *vma,
>  unsigned long old_addr, struct vm_area_struct *new_vma,
>  unsigned long new_addr, unsigned long len);
>extern unsigned long do_mremap(unsigned long addr,
>          unsigned long old_len, unsigned long new_len,
>          unsigned long flags, unsigned long new_addr);
>extern int mprotect_fixup(struct vm_area_struct *vma,
>     struct vm_area_struct **pprev, unsigned long start,
>     unsigned long end, unsigned long newflags);
># 848 "include/linux/mm.h"
>struct shrinker {
> int (*shrink)(int nr_to_scan, gfp_t gfp_mask);
> int seeks;
>
>
> struct list_head list;
> long nr;
>};
>
>extern void register_shrinker(struct shrinker *);
>extern void unregister_shrinker(struct shrinker *);
>
>int vma_wants_writenotify(struct vm_area_struct *vma);
>
>extern pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl);
>
>
>static inline __attribute__((always_inline)) int __pud_alloc(struct mm_struct *mm, pgd_t *pgd,
>      unsigned long address)
>{
> return 0;
>}
># 881 "include/linux/mm.h"
>int __pmd_alloc(struct mm_struct *mm, pud_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);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
>{
> return (__builtin_expect(!!(pgd_none(*pgd)), 0) && __pud_alloc(mm, pgd, address))?
>  ((void *)0): pud_offset(pgd, address);
>}
>
>static inline __attribute__((always_inline)) pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
>{
> return (__builtin_expect(!!((!(((((*pud).pgd).pgd)) & ~0x002))), 0) && __pmd_alloc(mm, pud, address))?
>  ((void *)0): ((pmd_t *) ((unsigned long) to_virt((unsigned long) (((((*(pud)).pgd).pgd)) & (~(((1UL) << 12)-1))))) + (((address) >> 21) & (512 -1)));
>}
># 927 "include/linux/mm.h"
>static inline __attribute__((always_inline)) void pgtable_page_ctor(struct page *page)
>{
> do {} while (0);
> __inc_zone_page_state(page, NR_PAGETABLE);
>}
>
>static inline __attribute__((always_inline)) void pgtable_page_dtor(struct page *page)
>{
> do {} while (0);
> __dec_zone_page_state(page, NR_PAGETABLE);
>}
># 965 "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);
># 1018 "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, enum memmap_context);
>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);
>
>
>
>
>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(struct mm_struct *mm, 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 void added_exe_file_vma(struct mm_struct *mm);
>extern void removed_exe_file_vma(struct mm_struct *mm);
># 1082 "include/linux/mm.h"
>extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
>extern int install_special_mapping(struct mm_struct *mm,
>       unsigned long addr, unsigned long len,
>       unsigned long flags, struct page **pages);
>
>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);
>extern unsigned long mmap_region(struct file *file, unsigned long addr,
> unsigned long len, unsigned long flags,
> unsigned int vm_flags, unsigned long pgoff,
> int accountable);
>
>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 int filemap_fault(struct vm_area_struct *, struct vm_fault *);
>
>
>int write_one_page(struct page *page, int wait);
>
>
>
>
>
>int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
>   unsigned long offset, unsigned long nr_to_read);
>int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
>   unsigned long offset, unsigned long nr_to_read);
>
>void page_cache_sync_readahead(struct address_space *mapping,
>          struct file_ra_state *ra,
>          struct file *filp,
>          unsigned long offset,
>          unsigned long size);
>
>void page_cache_async_readahead(struct address_space *mapping,
>    struct file_ra_state *ra,
>    struct file *filp,
>    struct page *pg,
>    unsigned long offset,
>    unsigned long size);
>
>unsigned long max_sane_readahead(unsigned long nr);
>
>
>extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
>
>
>
>extern int expand_stack_downwards(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);
>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 *);
>int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
>   unsigned long pfn);
>int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
>   unsigned long pfn);
>
>struct page *follow_page(struct vm_area_struct *, unsigned long address,
>   unsigned int foll_flags);
>
>
>
>
>
>typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr,
>   void *data);
>extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
>          unsigned long size, pte_fn_t fn, void *data);
>
>
>void vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
># 1223 "include/linux/mm.h"
>static inline __attribute__((always_inline)) void
>kernel_map_pages(struct page *page, int numpages, int enable) {}
>static inline __attribute__((always_inline)) void enable_debug_pagealloc(void)
>{
>}
>
>
>
>
>
>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);
>
>
>
>
>extern int randomize_va_space;
>
>
>const char * arch_vma_name(struct vm_area_struct *vma);
>void print_vma_addr(char *prefix, unsigned long rip);
>
>struct page *sparse_mem_map_populate(unsigned long pnum, int nid);
>pgd_t *vmemmap_pgd_populate(unsigned long addr, int node);
>pud_t *vmemmap_pud_populate(pgd_t *pgd, unsigned long addr, int node);
>pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node);
>pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node);
>void *vmemmap_alloc_block(unsigned long size, int node);
>void vmemmap_verify(pte_t *, int, unsigned long, unsigned long);
>int vmemmap_populate_basepages(struct page *start_page,
>      unsigned long pages, int node);
>int vmemmap_populate(struct page *start_page, unsigned long pages, int node);
>void vmemmap_populate_print_last(void);
># 30 "kernel/sched.c" 2
>
># 1 "include/linux/module.h" 1
># 10 "include/linux/module.h"
>
># 1 "include/linux/stat.h" 1
>
>
>
>
>
>
># 1 "include/asm/stat.h" 1
>
>
>
>
># 1 "include/asm/arch/stat.h" 1
># 68 "include/asm/arch/stat.h"
>struct stat {
> unsigned long st_dev;
> unsigned long st_ino;
> unsigned long st_nlink;
>
> unsigned int st_mode;
> unsigned int st_uid;
> unsigned int st_gid;
> unsigned int __pad0;
> unsigned long st_rdev;
> long st_size;
> long st_blksize;
> long st_blocks;
>
> unsigned long st_atime;
> unsigned long st_atime_nsec;
> unsigned long st_mtime;
> unsigned long st_mtime_nsec;
> unsigned long st_ctime;
> unsigned long st_ctime_nsec;
> long __unused[3];
>};
>
>
>
>struct __old_kernel_stat {
> unsigned short st_dev;
> unsigned short st_ino;
> unsigned short st_mode;
> unsigned short st_nlink;
> unsigned short st_uid;
> unsigned short st_gid;
> unsigned short st_rdev;
>
>
>
>
>
>
> unsigned int st_size;
> unsigned int st_atime;
> unsigned int st_mtime;
> unsigned int st_ctime;
>
>};
># 5 "include/asm/stat.h" 2
># 7 "include/linux/stat.h" 2
># 60 "include/linux/stat.h"
>
># 1 "include/linux/time.h" 1
># 13 "include/linux/time.h"
>struct timespec {
> time_t tv_sec;
> long tv_nsec;
>};
>
>
>struct timeval {
> time_t tv_sec;
> suseconds_t tv_usec;
>};
>
>struct timezone {
> int tz_minuteswest;
> int tz_dsttime;
>};
># 40 "include/linux/time.h"
>static inline __attribute__((always_inline)) int timespec_equal(const struct timespec *a,
>                                 const struct timespec *b)
>{
> return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int timespec_compare(const struct timespec *lhs, const 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(const struct timeval *lhs, const 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 kernel_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;
>
>extern unsigned long read_persistent_clock(void);
>extern int update_persistent_clock(struct timespec now);
>extern int no_sync_cmos_clock ;
>void timekeeping_init(void);
>
>unsigned long get_seconds(void);
>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 timespec *times, int flags);
>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 void getboottime(struct timespec *ts);
>extern void monotonic_to_bootbased(struct timespec *ts);
>
>extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
>extern int timekeeping_valid_for_hres(void);
>extern void update_wall_time(void);
>extern void update_xtime_cache(u64 nsec);
># 134 "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;
>}
># 146 "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)) {
>
>
>  asm("" : "+r"(ns));
>
>  ns -= 1000000000L;
>  a->tv_sec++;
> }
> a->tv_nsec = ns;
>}
># 204 "include/linux/time.h"
>struct itimerspec {
> struct timespec it_interval;
> struct timespec it_value;
>};
>
>struct itimerval {
> struct timeval it_interval;
> struct timeval it_value;
>};
># 61 "include/linux/stat.h" 2
>
>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;
>};
># 11 "include/linux/module.h" 2
>
>
>
># 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;
>struct file;
>struct subprocess_info;
>
>
>struct subprocess_info *call_usermodehelper_setup(char *path,
>        char **argv, char **envp);
>
>
>void call_usermodehelper_setkeys(struct subprocess_info *info,
>     struct key *session_keyring);
>int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
>      struct file **filp);
>void call_usermodehelper_setcleanup(struct subprocess_info *info,
>        void (*cleanup)(char **argv, char **envp));
>
>enum umh_wait {
> UMH_NO_WAIT = -1,
> UMH_WAIT_EXEC = 0,
> UMH_WAIT_PROC = 1,
>};
>
>
>int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
>
>
>
>void call_usermodehelper_freeinfo(struct subprocess_info *info);
>
>static inline __attribute__((always_inline)) int
>call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
>{
> struct subprocess_info *info;
>
> info = call_usermodehelper_setup(path, argv, envp);
> if (info == ((void *)0))
>  return -12;
> return call_usermodehelper_exec(info, wait);
>}
>
>static inline __attribute__((always_inline)) int
>call_usermodehelper_keys(char *path, char **argv, char **envp,
>    struct key *session_keyring, enum umh_wait wait)
>{
> struct subprocess_info *info;
>
> info = call_usermodehelper_setup(path, argv, envp);
> if (info == ((void *)0))
>  return -12;
>
> call_usermodehelper_setkeys(info, session_keyring);
> return call_usermodehelper_exec(info, wait);
>}
>
>extern void usermodehelper_init(void);
>
>struct file;
>extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[],
>        struct file **filp);
># 14 "include/linux/module.h" 2
>
># 1 "include/linux/elf.h" 1
>
>
>
>
>
># 1 "include/linux/elf-em.h" 1
># 6 "include/linux/elf.h" 2
>
>
>
>
>struct file;
># 20 "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;
># 127 "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;
># 150 "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;
># 289 "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;
># 365 "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;
># 388 "include/linux/elf.h"
>extern Elf64_Dyn _DYNAMIC [];
># 398 "include/linux/elf.h"
>static inline __attribute__((always_inline)) int elf_coredump_extra_notes_size(void) { return 0; }
>static inline __attribute__((always_inline)) int elf_coredump_extra_notes_write(struct file *file,
>   loff_t *foffset) { return 0; }
># 15 "include/linux/module.h" 2
>
>
># 1 "include/linux/kobject.h" 1
># 21 "include/linux/kobject.h"
>
># 1 "include/linux/sysfs.h" 1
># 20 "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;
> mode_t (*is_visible)(struct kobject *,
>           struct attribute *, int);
> struct attribute **attrs;
>};
># 62 "include/linux/sysfs.h"
>struct vm_area_struct;
>
>struct bin_attribute {
> struct attribute attr;
> size_t size;
> void *private;
> ssize_t (*read)(struct kobject *, struct bin_attribute *,
>   char *, loff_t, size_t);
> ssize_t (*write)(struct kobject *, struct bin_attribute *,
>    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);
>};
>
>
>
>int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
>       void *data, struct module *owner);
>
>int __attribute__((warn_unused_result)) sysfs_create_dir(struct kobject *kobj);
>void sysfs_remove_dir(struct kobject *kobj);
>int __attribute__((warn_unused_result)) sysfs_rename_dir(struct kobject *kobj, const char *new_name);
>int __attribute__((warn_unused_result)) sysfs_move_dir(struct kobject *kobj,
>    struct kobject *new_parent_kobj);
>
>int __attribute__((warn_unused_result)) sysfs_create_file(struct kobject *kobj,
>       const struct attribute *attr);
>int __attribute__((warn_unused_result)) sysfs_chmod_file(struct kobject *kobj, struct attribute *attr,
>      mode_t mode);
>void sysfs_remove_file(struct kobject *kobj, const struct attribute *attr);
>
>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_link(struct kobject *kobj, struct kobject *target,
>       const char *name);
>void sysfs_remove_link(struct kobject *kobj, const char *name);
>
>int __attribute__((warn_unused_result)) sysfs_create_group(struct kobject *kobj,
>        const struct attribute_group *grp);
>int sysfs_update_group(struct kobject *kobj,
>         const struct attribute_group *grp);
>void sysfs_remove_group(struct kobject *kobj,
>   const struct attribute_group *grp);
>int sysfs_add_file_to_group(struct kobject *kobj,
>   const struct attribute *attr, const char *group);
>void sysfs_remove_file_from_group(struct kobject *kobj,
>   const struct attribute *attr, const char *group);
>
>void sysfs_notify(struct kobject *kobj, char *dir, char *attr);
>
>extern int __attribute__((warn_unused_result)) sysfs_init(void);
># 22 "include/linux/kobject.h" 2
>
>
>
># 1 "include/linux/kref.h" 1
># 21 "include/linux/kref.h"
>struct kref {
> atomic_t refcount;
>};
>
>void kref_set(struct kref *kref, int num);
>void kref_init(struct kref *kref);
>void kref_get(struct kref *kref);
>int kref_put(struct kref *kref, void (*release) (struct kref *kref));
># 25 "include/linux/kobject.h" 2
># 35 "include/linux/kobject.h"
>extern char uevent_helper[];
>
>
>extern u64 uevent_seqnum;
># 50 "include/linux/kobject.h"
>enum kobject_action {
> KOBJ_ADD,
> KOBJ_REMOVE,
> KOBJ_CHANGE,
> KOBJ_MOVE,
> KOBJ_ONLINE,
> KOBJ_OFFLINE,
> KOBJ_MAX
>};
>
>struct kobject {
> const char *name;
> struct kref kref;
> struct list_head entry;
> struct kobject *parent;
> struct kset *kset;
> struct kobj_type *ktype;
> struct sysfs_dirent *sd;
> unsigned int state_initialized:1;
> unsigned int state_in_sysfs:1;
> unsigned int state_add_uevent_sent:1;
> unsigned int state_remove_uevent_sent:1;
>};
>
>extern int kobject_set_name(struct kobject *kobj, const char *name, ...)
>       __attribute__((format(printf, 2, 3)));
>
>static inline __attribute__((always_inline)) const char *kobject_name(const struct kobject *kobj)
>{
> return kobj->name;
>}
>
>extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
>extern int __attribute__((warn_unused_result)) kobject_add(struct kobject *kobj,
>        struct kobject *parent,
>        const char *fmt, ...);
>extern int __attribute__((warn_unused_result)) kobject_init_and_add(struct kobject *kobj,
>          struct kobj_type *ktype,
>          struct kobject *parent,
>          const char *fmt, ...);
>
>extern void kobject_del(struct kobject *kobj);
>
>extern struct kobject * __attribute__((warn_unused_result)) kobject_create(void);
>extern struct kobject * __attribute__((warn_unused_result)) kobject_create_and_add(const char *name,
>      struct kobject *parent);
>
>extern int __attribute__((warn_unused_result)) kobject_rename(struct kobject *, const char *new_name);
>extern int __attribute__((warn_unused_result)) kobject_move(struct kobject *, struct kobject *);
>
>extern struct kobject *kobject_get(struct kobject *kobj);
>extern void kobject_put(struct kobject *kobj);
>
>extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);
>
>struct kobj_type {
> void (*release)(struct kobject *kobj);
> struct sysfs_ops *sysfs_ops;
> struct attribute **default_attrs;
>};
>
>struct kobj_uevent_env {
> char *envp[32];
> int envp_idx;
> char buf[2048];
> int buflen;
>};
>
>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,
>        struct kobj_uevent_env *env);
>};
>
>struct kobj_attribute {
> struct attribute attr;
> ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
>   char *buf);
> ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
>    const char *buf, size_t count);
>};
>
>extern struct sysfs_ops kobj_sysfs_ops;
># 152 "include/linux/kobject.h"
>struct kset {
> struct list_head list;
> spinlock_t list_lock;
> struct kobject kobj;
> struct kset_uevent_ops *uevent_ops;
>};
>
>extern void kset_init(struct kset *kset);
>extern int __attribute__((warn_unused_result)) kset_register(struct kset *kset);
>extern void kset_unregister(struct kset *kset);
>extern struct kset * __attribute__((warn_unused_result)) kset_create_and_add(const char *name,
>      struct kset_uevent_ops *u,
>      struct kobject *parent_kobj);
>
>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 *kobj)
>{
> return kobj->ktype;
>}
>
>extern struct kobject *kset_find_obj(struct kset *, const char *);
>
>
>extern struct kobject *kernel_kobj;
>
>extern struct kobject *hypervisor_kobj;
>
>extern struct kobject *power_kobj;
>
>extern struct kobject *firmware_kobj;
>
>
>int kobject_uevent(struct kobject *kobj, enum kobject_action action);
>int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
>   char *envp[]);
>
>int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
> __attribute__((format (printf, 2, 3)));
>
>int kobject_action_type(const char *buf, size_t count,
>   enum kobject_action *type);
># 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;
> union {
>  void *arg;
>  const struct kparam_string *str;
>  const struct kparam_array *arr;
> };
>};
>
>
>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;
>};
># 112 "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);
># 176 "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);
># 18 "include/linux/module.h" 2
>
># 1 "include/linux/marker.h" 1
># 17 "include/linux/marker.h"
>struct module;
>struct marker;
># 32 "include/linux/marker.h"
>typedef void marker_probe_func(void *probe_private, void *call_private,
>  const char *fmt, va_list *args);
>
>struct marker_probe_closure {
> marker_probe_func *func;
> void *probe_private;
>};
>
>struct marker {
> const char *name;
> const char *format;
>
>
> char state;
> char ptype;
> void (*call)(const struct marker *mdata,
>  void *call_private, const char *fmt, ...);
> struct marker_probe_closure single;
> struct marker_probe_closure *multi;
>} __attribute__((aligned(8)));
># 85 "include/linux/marker.h"
>static inline __attribute__((always_inline)) void marker_update_probe_range(struct marker *begin,
> struct marker *end)
>{ }
># 107 "include/linux/marker.h"
>static inline __attribute__((always_inline)) void __attribute__((format(printf,1,2))) ___mark_check_format(const char *fmt, ...)
>{
>}
>
>
>
>
>
>
>
>extern marker_probe_func __mark_empty_function;
>
>extern void marker_probe_cb(const struct marker *mdata,
> void *call_private, const char *fmt, ...);
>extern void marker_probe_cb_noarg(const struct marker *mdata,
> void *call_private, const char *fmt, ...);
>
>
>
>
>
>extern int marker_probe_register(const char *name, const char *format,
>    marker_probe_func *probe, void *probe_private);
>
>
>
>
>extern int marker_probe_unregister(const char *name,
> marker_probe_func *probe, void *probe_private);
>
>
>
>extern int marker_probe_unregister_private_data(marker_probe_func *probe,
> void *probe_private);
>
>extern void *marker_get_private_data(const char *name, marker_probe_func *probe,
> int num);
># 19 "include/linux/module.h" 2
>
># 1 "include/asm/local.h" 1
>
>
>
>
># 1 "include/asm/arch/local.h" 1
># 10 "include/asm/arch/local.h"
>typedef struct {
> atomic_long_t a;
>} local_t;
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void local_inc(local_t *l)
>{
> asm volatile(" incq " "%0"
>       : "+m" (l->a.counter));
>}
>
>static inline __attribute__((always_inline)) void local_dec(local_t *l)
>{
> asm volatile(" decq " "%0"
>       : "+m" (l->a.counter));
>}
>
>static inline __attribute__((always_inline)) void local_add(long i, local_t *l)
>{
> asm volatile(" addq " "%1,%0"
>       : "+m" (l->a.counter)
>       : "ir" (i));
>}
>
>static inline __attribute__((always_inline)) void local_sub(long i, local_t *l)
>{
> asm volatile(" subq " "%1,%0"
>       : "+m" (l->a.counter)
>       : "ir" (i));
>}
># 54 "include/asm/arch/local.h"
>static inline __attribute__((always_inline)) int local_sub_and_test(long i, local_t *l)
>{
> unsigned char c;
>
> asm volatile(" subq " "%2,%0; sete %1"
>       : "+m" (l->a.counter), "=qm" (c)
>       : "ir" (i) : "memory");
> return c;
>}
># 72 "include/asm/arch/local.h"
>static inline __attribute__((always_inline)) int local_dec_and_test(local_t *l)
>{
> unsigned char c;
>
> asm volatile(" decq " "%0; sete %1"
>       : "+m" (l->a.counter), "=qm" (c)
>       : : "memory");
> return c != 0;
>}
># 90 "include/asm/arch/local.h"
>static inline __attribute__((always_inline)) int local_inc_and_test(local_t *l)
>{
> unsigned char c;
>
> asm volatile(" incq " "%0; sete %1"
>       : "+m" (l->a.counter), "=qm" (c)
>       : : "memory");
> return c != 0;
>}
># 109 "include/asm/arch/local.h"
>static inline __attribute__((always_inline)) int local_add_negative(long i, local_t *l)
>{
> unsigned char c;
>
> asm volatile(" addq " "%2,%0; sets %1"
>       : "+m" (l->a.counter), "=qm" (c)
>       : "ir" (i) : "memory");
> return c;
>}
># 126 "include/asm/arch/local.h"
>static inline __attribute__((always_inline)) long local_add_return(long i, local_t *l)
>{
> long __i;
>
>
>
>
>
>
> __i = i;
> asm volatile(" xaddq " "%0, %1;"
>       : "+r" (i), "+m" (l->a.counter)
>       : : "memory");
> return i + __i;
># 149 "include/asm/arch/local.h"
>}
>
>static inline __attribute__((always_inline)) long local_sub_return(long i, local_t *l)
>{
> return local_add_return(-i, l);
>}
># 5 "include/asm/local.h" 2
># 20 "include/linux/module.h" 2
>
>
># 1 "include/asm/module.h" 1
># 11 "include/asm/module.h"
>struct mod_arch_specific
>{
>};
># 22 "include/linux/module.h" 2
># 33 "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;
> struct kobject *drivers_dir;
>};
>
>
>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);
># 163 "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);
># 220 "include/linux/module.h"
>struct module_ref
>{
> local_t count;
>} __attribute__((__aligned__((1 << 6))));
>
>enum module_state
>{
> MODULE_STATE_LIVE,
> MODULE_STATE_COMING,
> MODULE_STATE_GOING,
>};
>
>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;
> struct kobject *holders_dir;
>
>
> 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;
>
> unsigned int taints;
>
>
>
> struct list_head bug_list;
> struct bug_entry *bug_table;
> unsigned num_bugs;
>
>
>
>
> struct module_ref ref[1];
>
>
> struct list_head modules_which_use_me;
>
>
> struct task_struct *waiter;
>
>
> void (*exit)(void);
>
>
>
>
> Elf64_Sym *symtab;
> unsigned long num_symtab;
> char *strtab;
>
>
> struct module_sect_attrs *sect_attrs;
>
>
> struct module_notes_attrs *notes_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);
>
>
>
>int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
>   char *name, char *module_name, int *exported);
>
>
>unsigned long module_kallsyms_lookup_name(const char *name);
>
>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)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/module.h", 386, (__func__)); panic("BUG!"); } while (0); } while(0);
>  local_inc(&module->ref[({ do { } while (0); 0; })].count);
>  do { } while (0);
> }
>}
>
>static inline __attribute__((always_inline)) int try_module_get(struct module *module)
>{
> int ret = 1;
>
> if (module) {
>  unsigned int cpu = ({ do { } while (0); 0; });
>  if (__builtin_expect(!!(module_is_live(module)), 1))
>   local_inc(&module->ref[cpu].count);
>  else
>   ret = 0;
>  do { } while (0);
> }
> return ret;
>}
>
>extern void module_put(struct module *module);
># 435 "include/linux/module.h"
>const char *module_address_lookup(unsigned long addr,
>       unsigned long *symbolsize,
>       unsigned long *offset,
>       char **modname,
>       char *namebuf);
>int lookup_module_symbol_name(unsigned long addr, char *symname);
>int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
>
>
>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);
>
>extern void module_update_markers(void);
># 559 "include/linux/module.h"
>struct device_driver;
>
>struct module;
>
>extern struct kset *module_kset;
>extern struct kobj_type module_ktype;
>extern int module_sysfs_initialized;
>
>int mod_sysfs_init(struct module *mod);
>int mod_sysfs_setup(struct module *mod,
>      struct kernel_param *kparam,
>      unsigned int num_params);
>int module_add_modinfo_attrs(struct module *mod);
>void module_remove_modinfo_attrs(struct module *mod);
># 31 "kernel/sched.c" 2
>
># 1 "include/linux/nmi.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/sched.h" 1
># 44 "include/linux/sched.h"
>struct sched_param {
> int sched_priority;
>};
>
>
># 1 "include/asm/param.h" 1
># 49 "include/linux/sched.h" 2
>
>
># 1 "include/linux/capability.h" 1
># 18 "include/linux/capability.h"
>struct task_struct;
># 40 "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;
># 72 "include/linux/capability.h"
>struct vfs_cap_data {
> __le32 magic_etc;
> struct {
>  __le32 permitted;
>  __le32 inheritable;
> } data[2];
>};
>
>
>
>typedef struct kernel_cap_struct {
> __u32 cap[2];
>} kernel_cap_t;
># 403 "include/linux/capability.h"
>static inline __attribute__((always_inline)) kernel_cap_t cap_combine(const kernel_cap_t a,
>           const kernel_cap_t b)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] | b.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_intersect(const kernel_cap_t a,
>      const kernel_cap_t b)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] & b.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_drop(const kernel_cap_t a,
>        const kernel_cap_t drop)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] &~ drop.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_invert(const kernel_cap_t c)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = ~ c.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((always_inline)) int cap_isclear(const kernel_cap_t a)
>{
> unsigned __capi;
> for (__capi = 0; __capi < 2; ++__capi) {
>  if (a.cap[__capi] != 0)
>   return 0;
> }
> return 1;
>}
>
>static inline __attribute__((always_inline)) int cap_issubset(const kernel_cap_t a, const kernel_cap_t set)
>{
> kernel_cap_t dest;
> dest = cap_drop(a, set);
> return cap_isclear(dest);
>}
>
>
>
>static inline __attribute__((always_inline)) int cap_is_fs_cap(int cap)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))), ((1 << ((32) & 31))) } });
> return !!((1 << ((cap) & 31)) & __cap_fs_set.cap[((cap) >> 5)]);
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_drop_fs_set(const kernel_cap_t a)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))), ((1 << ((32) & 31))) } });
> return cap_drop(a, __cap_fs_set);
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_raise_fs_set(const kernel_cap_t a,
>         const kernel_cap_t permitted)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))), ((1 << ((32) & 31))) } });
> return cap_combine(a,
>      cap_intersect(permitted, __cap_fs_set));
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_drop_nfsd_set(const kernel_cap_t a)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31)))|(1 << ((24) & 31)), ((1 << ((32) & 31))) } });
> return cap_drop(a, __cap_fs_set);
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_raise_nfsd_set(const kernel_cap_t a,
>           const kernel_cap_t permitted)
>{
> const kernel_cap_t __cap_nfsd_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31)))|(1 << ((24) & 31)), ((1 << ((32) & 31))) } });
> return cap_combine(a,
>      cap_intersect(permitted, __cap_nfsd_set));
>}
>
>extern const kernel_cap_t __cap_empty_set;
>extern const kernel_cap_t __cap_full_set;
>extern const kernel_cap_t __cap_init_eff_set;
>
>int capable(int cap);
>int __capable(struct task_struct *t, int cap);
># 51 "include/linux/sched.h" 2
>
>
>
>
># 1 "include/linux/timex.h" 1
># 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 tai;
>
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32;
>};
># 195 "include/linux/timex.h"
>
># 1 "include/asm/timex.h" 1
>
>
>
>typedef unsigned long cycles_t;
>
>static inline __attribute__((always_inline)) cycles_t get_cycles (void)
>{
> return 0;
>}
># 196 "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_adjust;
>
>extern void ntp_init(void);
>extern void ntp_clear(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) int ntp_synced(void)
>{
> return !(time_status & 0x0040);
>}
># 244 "include/linux/timex.h"
>extern u64 tick_length;
>
>extern void second_overflow(void);
>extern void update_ntp_one_tick(void);
>extern int do_adjtimex(struct timex *);
>
>
>
>
>int read_current_timer(unsigned long *timer_val);
># 55 "include/linux/sched.h" 2
>
># 1 "include/linux/jiffies.h" 1
>
>
>
>
># 1 "include/linux/math64.h" 1
>
>
>
>
>
># 1 "include/asm/div64.h" 1
>
>
>
>
># 1 "include/asm/arch/div64.h" 1
># 57 "include/asm/arch/div64.h"
>
># 1 "include/asm-generic/div64.h" 1
># 58 "include/asm/arch/div64.h" 2
># 5 "include/asm/div64.h" 2
># 6 "include/linux/math64.h" 2
># 15 "include/linux/math64.h"
>static inline __attribute__((always_inline)) u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
>{
> *remainder = dividend % divisor;
> return dividend / divisor;
>}
>
>
>
>
>static inline __attribute__((always_inline)) s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)
>{
> *remainder = dividend % divisor;
> return dividend / divisor;
>}
>
>
>
>
>static inline __attribute__((always_inline)) u64 div64_u64(u64 dividend, u64 divisor)
>{
> return dividend / divisor;
>}
># 66 "include/linux/math64.h"
>static inline __attribute__((always_inline)) u64 div_u64(u64 dividend, u32 divisor)
>{
> u32 remainder;
> return div_u64_rem(dividend, divisor, &remainder);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) s64 div_s64(s64 dividend, s32 divisor)
>{
> s32 remainder;
> return div_s64_rem(dividend, divisor, &remainder);
>}
># 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;
>
>
>
>
>static inline __attribute__((always_inline)) u64 get_jiffies_64(void)
>{
> return (u64)jiffies;
>}
># 173 "include/linux/jiffies.h"
>extern unsigned long preset_lpj;
># 286 "include/linux/jiffies.h"
>extern unsigned int jiffies_to_msecs(const unsigned long j);
>extern unsigned int jiffies_to_usecs(const unsigned long j);
>extern unsigned long msecs_to_jiffies(const unsigned int m);
>extern unsigned long usecs_to_jiffies(const unsigned int u);
>extern unsigned long timespec_to_jiffies(const struct timespec *value);
>extern void jiffies_to_timespec(const unsigned long jiffies,
>    struct timespec *value);
>extern unsigned long timeval_to_jiffies(const struct timeval *value);
>extern void jiffies_to_timeval(const unsigned long jiffies,
>          struct timeval *value);
>extern clock_t jiffies_to_clock_t(long x);
>extern unsigned long clock_t_to_jiffies(unsigned long x);
>extern u64 jiffies_64_to_clock_t(u64 x);
>extern u64 nsec_to_clock_t(u64 x);
># 56 "include/linux/sched.h" 2
># 66 "include/linux/sched.h"
>
># 1 "include/asm/cputime.h" 1
>
>
>
>
># 1 "include/asm-generic/cputime.h" 1
>
>
>
>
>
>
>typedef unsigned long cputime_t;
># 24 "include/asm-generic/cputime.h"
>typedef u64 cputime64_t;
># 5 "include/asm/cputime.h" 2
># 67 "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
>
>
>
>
># 1 "include/asm/arch/ipcbuf.h" 1
># 14 "include/asm/arch/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;
>};
># 5 "include/asm/ipcbuf.h" 2
># 22 "include/linux/ipc.h" 2
># 57 "include/linux/ipc.h"
>struct ipc_kludge {
> struct msgbuf *msgp;
> long msgtyp;
>};
># 88 "include/linux/ipc.h"
>struct kern_ipc_perm
>{
> spinlock_t lock;
> int deleted;
> int id;
> key_t key;
> uid_t uid;
> gid_t gid;
> uid_t cuid;
> gid_t cgid;
> mode_t mode;
> unsigned long seq;
> void *security;
>};
># 5 "include/linux/sem.h" 2
># 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
>
>
>
>
># 1 "include/asm/arch/sembuf.h" 1
># 13 "include/asm/arch/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;
>};
># 5 "include/asm/sembuf.h" 2
># 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;
> 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;
>};
>
>
>
>extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
>extern void exit_sem(struct task_struct *tsk);
># 70 "include/linux/sched.h" 2
>
># 1 "include/linux/signal.h" 1
>
>
>
>
># 1 "include/asm/signal.h" 1
># 12 "include/asm/signal.h"
>
># 1 "include/asm/arch/signal.h" 1
># 10 "include/asm/arch/signal.h"
>struct siginfo;
># 28 "include/asm/arch/signal.h"
>typedef unsigned long old_sigset_t;
>
>typedef struct {
> unsigned long sig[(64 / 64)];
>} sigset_t;
># 120 "include/asm/arch/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;
># 121 "include/asm/arch/signal.h" 2
># 162 "include/asm/arch/signal.h"
>struct sigaction {
> __sighandler_t sa_handler;
> unsigned long sa_flags;
> __sigrestore_t sa_restorer;
> sigset_t sa_mask;
>};
>
>struct k_sigaction {
> struct sigaction sa;
>};
>
>
>
>typedef struct sigaltstack {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
>} stack_t;
>
>
>
># 1 "include/asm/sigcontext.h" 1
># 9 "include/asm/sigcontext.h"
>
># 1 "include/asm/sigcontext-generic.h" 1
>
>
>
>
># 1 "include/asm/arch/sigcontext.h" 1
># 121 "include/asm/arch/sigcontext.h"
>struct _fpstate {
> __u16 cwd;
> __u16 swd;
> __u16 twd;
>
> __u16 fop;
> __u64 rip;
> __u64 rdp;
> __u32 mxcsr;
> __u32 mxcsr_mask;
> __u32 st_space[32];
> __u32 xmm_space[64];
> __u32 reserved2[24];
>};
>
>
>struct sigcontext {
> unsigned long r8;
> unsigned long r9;
> unsigned long r10;
> unsigned long r11;
> unsigned long r12;
> unsigned long r13;
> unsigned long r14;
> unsigned long r15;
> unsigned long di;
> unsigned long si;
> unsigned long bp;
> unsigned long bx;
> unsigned long dx;
> unsigned long ax;
> unsigned long cx;
> unsigned long sp;
> unsigned long ip;
> unsigned long flags;
> unsigned short cs;
> unsigned short gs;
> unsigned short fs;
> unsigned short __pad0;
> unsigned long err;
> unsigned long trapno;
> unsigned long oldmask;
> unsigned long cr2;
> struct _fpstate *fpstate;
> unsigned long reserved1[8];
>};
># 5 "include/asm/sigcontext-generic.h" 2
># 10 "include/asm/sigcontext.h" 2
># 183 "include/asm/arch/signal.h" 2
># 13 "include/asm/signal.h" 2
># 5 "include/linux/signal.h" 2
>
># 1 "include/asm/siginfo.h" 1
>
>
>
>
># 1 "include/asm/arch/siginfo.h" 1
># 9 "include/asm/arch/siginfo.h"
># 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 - (4 * sizeof(int))) / sizeof(int))];
>
>
>  struct {
>   pid_t _pid;
>   uid_t _uid;
>  } _kill;
>
>
>  struct {
>   timer_t _tid;
>   int _overrun;
>   char _pad[sizeof( uid_t) - sizeof(int)];
>   sigval_t _sigval;
>   int _sys_private;
>  } _timer;
>
>
>  struct {
>   pid_t _pid;
>   uid_t _uid;
>   sigval_t _sigval;
>  } _rt;
>
>
>  struct {
>   pid_t _pid;
>   uid_t _uid;
>   int _status;
>   clock_t _utime;
>   clock_t _stime;
>  } _sigchld;
>
>
>  struct {
>   void *_addr;
>
>
>
>  } _sigfault;
>
>
>  struct {
>   long _band;
>   int _fd;
>  } _sigpoll;
> } _sifields;
>} siginfo_t;
># 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, (4 * sizeof(int)) + sizeof(from->_sifields._sigchld));
>}
>
>
>
>extern int copy_siginfo_to_user(struct siginfo *to, struct siginfo *from);
># 9 "include/asm/arch/siginfo.h" 2
># 5 "include/asm/siginfo.h" 2
># 6 "include/linux/signal.h" 2
># 14 "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;
>};
># 38 "include/linux/signal.h"
>static inline __attribute__((always_inline)) void sigaddset(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 64) == 1)
>  set->sig[0] |= 1UL << sig;
> else
>  set->sig[sig / 64] |= 1UL << (sig % 64);
>}
>
>static inline __attribute__((always_inline)) void sigdelset(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 64) == 1)
>  set->sig[0] &= ~(1UL << sig);
> else
>  set->sig[sig / 64] &= ~(1UL << (sig % 64));
>}
>
>static inline __attribute__((always_inline)) int sigismember(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 64) == 1)
>  return 1 & (set->sig[0] >> sig);
> else
>  return 1 & (set->sig[sig / 64] >> (sig % 64));
>}
>
>static inline __attribute__((always_inline)) int sigfindinword(unsigned long word)
>{
> return ffz(~word);
>}
>
>
>
>static inline __attribute__((always_inline)) int sigisemptyset(sigset_t *set)
>{
> extern void _NSIG_WORDS_is_unsupported_size(void);
> switch ((64 / 64)) {
> 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;
> }
>}
># 119 "include/linux/signal.h"
>static inline __attribute__((always_inline)) void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) | (b3)); r->sig[2] = ((a2) | (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) | (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) | (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
>
>
>static inline __attribute__((always_inline)) void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & (b3)); r->sig[2] = ((a2) & (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
>
>
>static inline __attribute__((always_inline)) void signandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & ~(b3)); r->sig[2] = ((a2) & ~(b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & ~(b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & ~(b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
># 149 "include/linux/signal.h"
>static inline __attribute__((always_inline)) void signotset(sigset_t *set) { extern void _NSIG_WORDS_is_unsupported_size(void); switch ((64 / 64)) { case 4: set->sig[3] = (~(set->sig[3])); set->sig[2] = (~(set->sig[2])); case 2: set->sig[1] = (~(set->sig[1])); case 1: set->sig[0] = (~(set->sig[0])); break; default: _NSIG_WORDS_is_unsupported_size(); } }
>
>
>
>
>static inline __attribute__((always_inline)) void sigemptyset(sigset_t *set)
>{
> switch ((64 / 64)) {
> default:
>  memset(set, 0, sizeof(sigset_t));
>  break;
> case 2: set->sig[1] = 0;
> case 1: set->sig[0] = 0;
>  break;
> }
>}
>
>static inline __attribute__((always_inline)) void sigfillset(sigset_t *set)
>{
> switch ((64 / 64)) {
> default:
>  memset(set, -1, sizeof(sigset_t));
>  break;
> case 2: set->sig[1] = -1;
> case 1: set->sig[0] = -1;
>  break;
> }
>}
>
>
>
>static inline __attribute__((always_inline)) void sigaddsetmask(sigset_t *set, unsigned long mask)
>{
> set->sig[0] |= mask;
>}
>
>static inline __attribute__((always_inline)) void sigdelsetmask(sigset_t *set, unsigned long mask)
>{
> set->sig[0] &= ~mask;
>}
>
>static inline __attribute__((always_inline)) int sigtestsetmask(sigset_t *set, unsigned long mask)
>{
> return (set->sig[0] & mask) != 0;
>}
>
>static inline __attribute__((always_inline)) void siginitset(sigset_t *set, unsigned long mask)
>{
> set->sig[0] = mask;
> switch ((64 / 64)) {
> default:
>  memset(&set->sig[1], 0, sizeof(long)*((64 / 64)-1));
>  break;
> case 2: set->sig[1] = 0;
> case 1: ;
> }
>}
>
>static inline __attribute__((always_inline)) void siginitsetinv(sigset_t *set, unsigned long mask)
>{
> set->sig[0] = ~mask;
> switch ((64 / 64)) {
> default:
>  memset(&set->sig[1], -1, sizeof(long)*((64 / 64)-1));
>  break;
> case 2: set->sig[1] = -1;
> case 1: ;
> }
>}
>
>
>
>static inline __attribute__((always_inline)) void init_sigpending(struct sigpending *sig)
>{
> sigemptyset(&sig->signal);
> 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 next_signal(struct sigpending *pending, sigset_t *mask);
>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 kernel_sigprocmask(int, sigset_t *, sigset_t *);
>extern int show_unhandled_signals;
>
>struct pt_regs;
>extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
>extern void exit_signals(struct task_struct *tsk);
>
>extern struct kmem_cache *sighand_cachep;
>
>int unhandled_signal(struct task_struct *tsk, int sig);
># 373 "include/linux/signal.h"
>void signals_init(void);
># 71 "include/linux/sched.h" 2
>
># 1 "include/linux/fs_struct.h" 1
>
>
>
>
># 1 "include/linux/path.h" 1
>
>
>
>struct dentry;
>struct vfsmount;
>
>struct path {
> struct vfsmount *mnt;
> struct dentry *dentry;
>};
>
>extern void path_get(struct path *);
>extern void path_put(struct path *);
># 5 "include/linux/fs_struct.h" 2
>
>struct fs_struct {
> atomic_t count;
> rwlock_t lock;
> int umask;
> struct path root, pwd, altroot;
>};
>
>
>
>
>
>
>
>extern struct kmem_cache *fs_cachep;
>
>extern void exit_fs(struct task_struct *);
>extern void set_fs_altroot(void);
>extern void set_fs_root(struct fs_struct *, struct path *);
>extern void set_fs_pwd(struct fs_struct *, struct path *);
>extern struct fs_struct *copy_fs_struct(struct fs_struct *);
>extern void put_fs_struct(struct fs_struct *);
># 72 "include/linux/sched.h" 2
>
>
>
># 1 "include/linux/pid.h" 1
>
>
>
>
># 1 "include/linux/rcupdate.h" 1
># 49 "include/linux/rcupdate.h"
>struct rcu_head {
> struct rcu_head *next;
> void (*func)(struct rcu_head *head);
>};
>
>
>
># 1 "include/linux/rcuclassic.h" 1
># 45 "include/linux/rcuclassic.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);
># 154 "include/linux/rcuclassic.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);
># 56 "include/linux/rcupdate.h" 2
># 200 "include/linux/rcupdate.h"
>extern void call_rcu(struct rcu_head *head,
>         void (*func)(struct rcu_head *head));
># 221 "include/linux/rcupdate.h"
>extern void call_rcu_bh(struct rcu_head *head,
>   void (*func)(struct rcu_head *head));
>
>
>extern void synchronize_rcu(void);
>extern void rcu_barrier(void);
>extern long rcu_batches_completed(void);
>extern long rcu_batches_completed_bh(void);
>
>
>extern void rcu_init(void);
>extern int rcu_needs_cpu(int cpu);
># 5 "include/linux/pid.h" 2
>
>enum pid_type
>{
> PIDTYPE_PID,
> PIDTYPE_PGID,
> PIDTYPE_SID,
> PIDTYPE_MAX
>};
># 50 "include/linux/pid.h"
>struct upid {
>
> int nr;
> struct pid_namespace *ns;
> struct hlist_node pid_chain;
>};
>
>struct pid
>{
> atomic_t count;
>
> struct hlist_head tasks[PIDTYPE_MAX];
> struct rcu_head rcu;
> unsigned int level;
> struct upid numbers[1];
>};
>
>extern struct pid init_struct_pid;
>
>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 void attach_pid(struct task_struct *task, enum pid_type type,
>   struct pid *pid);
>extern void detach_pid(struct task_struct *task, enum pid_type);
>extern void change_pid(struct task_struct *task, enum pid_type,
>   struct pid *pid);
>extern void transfer_pid(struct task_struct *old, struct task_struct *new,
>    enum pid_type);
>
>struct pid_namespace;
>extern struct pid_namespace init_pid_ns;
># 113 "include/linux/pid.h"
>extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns);
>extern struct pid *find_vpid(int nr);
>extern struct pid *find_pid(int nr);
>
>
>
>
>extern struct pid *find_get_pid(int nr);
>extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
>int next_pidmap(struct pid_namespace *pid_ns, int last);
>
>extern struct pid *alloc_pid(struct pid_namespace *ns);
>extern void free_pid(struct pid *pid);
># 138 "include/linux/pid.h"
>static inline __attribute__((always_inline)) pid_t pid_nr(struct pid *pid)
>{
> pid_t nr = 0;
> if (pid)
>  nr = pid->numbers[0].nr;
> return nr;
>}
>
>pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
>pid_t pid_vnr(struct pid *pid);
># 75 "include/linux/sched.h" 2
>
>
>
># 1 "include/linux/proportions.h" 1
># 12 "include/linux/proportions.h"
>
># 1 "include/linux/percpu_counter.h" 1
># 78 "include/linux/percpu_counter.h"
>struct percpu_counter {
> s64 count;
>};
>
>static inline __attribute__((always_inline)) int percpu_counter_init(struct percpu_counter *fbc, s64 amount)
>{
> fbc->count = amount;
> return 0;
>}
>
>
>
>static inline __attribute__((always_inline)) void percpu_counter_destroy(struct percpu_counter *fbc)
>{
>}
>
>static inline __attribute__((always_inline)) void percpu_counter_set(struct percpu_counter *fbc, s64 amount)
>{
> fbc->count = amount;
>}
>
>
>
>
>static inline __attribute__((always_inline)) void
>percpu_counter_add(struct percpu_counter *fbc, s64 amount)
>{
> do { } while (0);
> fbc->count += amount;
> do { } while (0);
>}
>
>static inline __attribute__((always_inline)) s64 percpu_counter_read(struct percpu_counter *fbc)
>{
> return fbc->count;
>}
>
>static inline __attribute__((always_inline)) s64 percpu_counter_read_positive(struct percpu_counter *fbc)
>{
> return fbc->count;
>}
>
>static inline __attribute__((always_inline)) s64 percpu_counter_sum_positive(struct percpu_counter *fbc)
>{
> return percpu_counter_read_positive(fbc);
>}
>
>static inline __attribute__((always_inline)) s64 percpu_counter_sum(struct percpu_counter *fbc)
>{
> return percpu_counter_read(fbc);
>}
>
>
>
>static inline __attribute__((always_inline)) void percpu_counter_inc(struct percpu_counter *fbc)
>{
> percpu_counter_add(fbc, 1);
>}
>
>static inline __attribute__((always_inline)) void percpu_counter_dec(struct percpu_counter *fbc)
>{
> percpu_counter_add(fbc, -1);
>}
>
>static inline __attribute__((always_inline)) void percpu_counter_sub(struct percpu_counter *fbc, s64 amount)
>{
> percpu_counter_add(fbc, -amount);
>}
># 13 "include/linux/proportions.h" 2
>
>
>
>struct prop_global {
>
>
>
>
>
> int shift;
>
>
>
>
>
>
> struct percpu_counter events;
>};
>
>
>
>
>
>
>struct prop_descriptor {
> int index;
> struct prop_global pg[2];
> struct mutex mutex;
>};
>
>int prop_descriptor_init(struct prop_descriptor *pd, int shift);
>void prop_change_shift(struct prop_descriptor *pd, int new_shift);
>
>
>
>
>
>struct prop_local_percpu {
>
>
>
> struct percpu_counter events;
>
>
>
>
> int shift;
> unsigned long period;
> spinlock_t lock;
>};
>
>int prop_local_init_percpu(struct prop_local_percpu *pl);
>void prop_local_destroy_percpu(struct prop_local_percpu *pl);
>void __prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl);
>void prop_fraction_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl,
>  long *numerator, long *denominator);
>
>static inline __attribute__((always_inline))
>void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0);
> __prop_inc_percpu(pd, pl);
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0);
>}
># 89 "include/linux/proportions.h"
>void __prop_inc_percpu_max(struct prop_descriptor *pd,
>      struct prop_local_percpu *pl, long frac);
>
>
>
>
>
>
>struct prop_local_single {
>
>
>
> unsigned long events;
>
>
>
>
>
> int shift;
> unsigned long period;
> spinlock_t lock;
>};
>
>
>
>
>
>int prop_local_init_single(struct prop_local_single *pl);
>void prop_local_destroy_single(struct prop_local_single *pl);
>void __prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl);
>void prop_fraction_single(struct prop_descriptor *pd, struct prop_local_single *pl,
>  long *numerator, long *denominator);
>
>static inline __attribute__((always_inline))
>void prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0);
> __prop_inc_single(pd, pl);
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0);
>}
># 78 "include/linux/sched.h" 2
>
># 1 "include/linux/seccomp.h" 1
># 24 "include/linux/seccomp.h"
>typedef struct { } seccomp_t;
>
>
>
>static inline __attribute__((always_inline)) long prctl_get_seccomp(void)
>{
> return -22;
>}
>
>static inline __attribute__((always_inline)) long prctl_set_seccomp(unsigned long arg2)
>{
> return -22;
>}
># 79 "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;
>};
># 127 "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);
># 195 "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);
>}
># 234 "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);
># 81 "include/linux/sched.h" 2
>
>
>
># 1 "include/linux/param.h" 1
># 84 "include/linux/sched.h" 2
>
># 1 "include/linux/resource.h" 1
>
>
>
>
>
>struct task_struct;
># 24 "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;
>};
># 71 "include/linux/resource.h"
>
># 1 "include/asm/resource.h" 1
>
>
>
>
># 1 "include/asm/arch/resource.h" 1
>
># 1 "include/asm-generic/resource.h" 1
># 1 "include/asm/arch/resource.h" 2
># 5 "include/asm/resource.h" 2
># 72 "include/linux/resource.h" 2
>
>int getrusage(struct task_struct *p, int who, struct rusage *ru);
># 85 "include/linux/sched.h" 2
>
># 1 "include/linux/timer.h" 1
>
>
>
>
>
># 1 "include/linux/ktime.h" 1
># 46 "include/linux/ktime.h"
>union ktime {
> s64 tv64;
># 57 "include/linux/ktime.h"
>};
>
>typedef union ktime ktime_t;
># 81 "include/linux/ktime.h"
>static inline __attribute__((always_inline)) ktime_t ktime_set(const long secs, const unsigned long nsecs)
>{
>
> if (__builtin_expect(!!(secs >= (((s64)~((u64)1 << 63)) / 1000000000L)), 0))
>  return (ktime_t){ .tv64 = ((s64)~((u64)1 << 63)) };
>
> return (ktime_t) { .tv64 = (s64)secs * 1000000000L + (s64)nsecs };
>}
># 113 "include/linux/ktime.h"
>static inline __attribute__((always_inline)) ktime_t timespec_to_ktime(struct timespec ts)
>{
> return ktime_set(ts.tv_sec, ts.tv_nsec);
>}
>
>
>static inline __attribute__((always_inline)) ktime_t timeval_to_ktime(struct timeval tv)
>{
> return ktime_set(tv.tv_sec, tv.tv_usec * 1000L);
>}
># 287 "include/linux/ktime.h"
>static inline __attribute__((always_inline)) int ktime_equal(const ktime_t cmp1, const ktime_t cmp2)
>{
> return cmp1.tv64 == cmp2.tv64;
>}
>
>static inline __attribute__((always_inline)) s64 ktime_to_us(const ktime_t kt)
>{
> struct timeval tv = ns_to_timeval((kt).tv64);
> return (s64) tv.tv_sec * 1000000L + tv.tv_usec;
>}
>
>static inline __attribute__((always_inline)) s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
>{
>       return ktime_to_us(({ (ktime_t){ .tv64 = (later).tv64 - (earlier).tv64 }; }));
>}
>
>static inline __attribute__((always_inline)) ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
>{
> return ({ (ktime_t){ .tv64 = (kt).tv64 + (usec * 1000) }; });
>}
>
>static inline __attribute__((always_inline)) ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
>{
> return ({ (ktime_t){ .tv64 = (kt).tv64 - (usec * 1000) }; });
>}
>
>extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);
># 325 "include/linux/ktime.h"
>extern void ktime_get_ts(struct timespec *ts);
>
>
>
>
>static inline __attribute__((always_inline)) ktime_t ns_to_ktime(u64 ns)
>{
> static const ktime_t ktime_zero = { .tv64 = 0 };
> return ({ (ktime_t){ .tv64 = (ktime_zero).tv64 + (ns) }; });
>}
># 6 "include/linux/timer.h" 2
>
>
># 1 "include/linux/debugobjects.h" 1
>
>
>
>
>
>
>enum debug_obj_state {
> ODEBUG_STATE_NONE,
> ODEBUG_STATE_INIT,
> ODEBUG_STATE_INACTIVE,
> ODEBUG_STATE_ACTIVE,
> ODEBUG_STATE_DESTROYED,
> ODEBUG_STATE_NOTAVAILABLE,
> ODEBUG_STATE_MAX,
>};
>
>struct debug_obj_descr;
># 26 "include/linux/debugobjects.h"
>struct debug_obj {
> struct hlist_node node;
> enum debug_obj_state state;
> void *object;
> struct debug_obj_descr *descr;
>};
># 45 "include/linux/debugobjects.h"
>struct debug_obj_descr {
> const char *name;
>
> int (*fixup_init) (void *addr, enum debug_obj_state state);
> int (*fixup_activate) (void *addr, enum debug_obj_state state);
> int (*fixup_destroy) (void *addr, enum debug_obj_state state);
> int (*fixup_free) (void *addr, enum debug_obj_state state);
>};
># 66 "include/linux/debugobjects.h"
>static inline __attribute__((always_inline)) void
>debug_object_init (void *addr, struct debug_obj_descr *descr) { }
>static inline __attribute__((always_inline)) void
>debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr) { }
>static inline __attribute__((always_inline)) void
>debug_object_activate (void *addr, struct debug_obj_descr *descr) { }
>static inline __attribute__((always_inline)) void
>debug_object_deactivate(void *addr, struct debug_obj_descr *descr) { }
>static inline __attribute__((always_inline)) void
>debug_object_destroy (void *addr, struct debug_obj_descr *descr) { }
>static inline __attribute__((always_inline)) void
>debug_object_free (void *addr, struct debug_obj_descr *descr) { }
>
>static inline __attribute__((always_inline)) void debug_objects_early_init(void) { }
>static inline __attribute__((always_inline)) void debug_objects_mem_init(void) { }
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>debug_check_no_obj_freed(const void *address, unsigned long size) { }
># 8 "include/linux/timer.h" 2
>
>struct tvec_base;
>
>struct timer_list {
> struct list_head entry;
> unsigned long expires;
>
> void (*function)(unsigned long);
> unsigned long data;
>
> struct tvec_base *base;
>
>
>
>
>
>};
>
>extern struct tvec_base boot_tvec_bases;
># 40 "include/linux/timer.h"
>void init_timer(struct timer_list *timer);
>void init_timer_deferrable(struct timer_list *timer);
>
>
>
>
>
>static inline __attribute__((always_inline)) void destroy_timer_on_stack(struct timer_list *timer) { }
>static inline __attribute__((always_inline)) void init_timer_on_stack(struct timer_list *timer)
>{
> init_timer(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);
>}
>
>static inline __attribute__((always_inline)) void setup_timer_on_stack(struct timer_list *timer,
>     void (*function)(unsigned long),
>     unsigned long data)
>{
> timer->function = function;
> timer->data = data;
> init_timer_on_stack(timer);
>}
># 82 "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);
># 102 "include/linux/timer.h"
>extern unsigned long next_timer_interrupt(void);
>
>
>
>
>
>extern unsigned long get_next_timer_interrupt(unsigned long now);
># 136 "include/linux/timer.h"
>static inline __attribute__((always_inline)) void init_timer_stats(void)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_timer_set_start_info(struct timer_list *timer)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_timer_clear_start_info(struct timer_list *timer)
>{
>}
># 163 "include/linux/timer.h"
>static inline __attribute__((always_inline)) void add_timer(struct timer_list *timer)
>{
> do { if (__builtin_expect(!!(timer_pending(timer)), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/timer.h", 165, (__func__)); panic("BUG!"); } while (0); } while(0);
> __mod_timer(timer, timer->expires);
>}
># 179 "include/linux/timer.h"
>extern void init_timers(void);
>extern void run_local_timers(void);
>struct hrtimer;
>extern enum hrtimer_restart it_real_fn(struct hrtimer *);
>
>unsigned long __round_jiffies(unsigned long j, int cpu);
>unsigned long __round_jiffies_relative(unsigned long j, int cpu);
>unsigned long round_jiffies(unsigned long j);
>unsigned long round_jiffies_relative(unsigned long j);
># 86 "include/linux/sched.h" 2
>
># 1 "include/linux/hrtimer.h" 1
># 24 "include/linux/hrtimer.h"
>struct hrtimer_clock_base;
>struct hrtimer_cpu_base;
>
>
>
>
>enum hrtimer_mode {
> HRTIMER_MODE_ABS,
> HRTIMER_MODE_REL,
>};
>
>
>
>
>enum hrtimer_restart {
> HRTIMER_NORESTART,
> HRTIMER_RESTART,
>};
># 53 "include/linux/hrtimer.h"
>enum hrtimer_cb_mode {
> HRTIMER_CB_SOFTIRQ,
> HRTIMER_CB_IRQSAFE,
> HRTIMER_CB_IRQSAFE_NO_RESTART,
> HRTIMER_CB_IRQSAFE_NO_SOFTIRQ,
>};
># 112 "include/linux/hrtimer.h"
>struct hrtimer {
> struct rb_node node;
> ktime_t expires;
> enum hrtimer_restart (*function)(struct hrtimer *);
> struct hrtimer_clock_base *base;
> unsigned long state;
> enum hrtimer_cb_mode cb_mode;
> struct list_head cb_entry;
>
>
>
>
>
>};
># 134 "include/linux/hrtimer.h"
>struct hrtimer_sleeper {
> struct hrtimer timer;
> struct task_struct *task;
>};
># 153 "include/linux/hrtimer.h"
>struct hrtimer_clock_base {
> struct hrtimer_cpu_base *cpu_base;
> clockid_t index;
> struct rb_root active;
> struct rb_node *first;
> ktime_t resolution;
> ktime_t (*get_time)(void);
> ktime_t (*get_softirq_time)(void);
> ktime_t softirq_time;
>
> ktime_t offset;
> int (*reprogram)(struct hrtimer *t,
>          struct hrtimer_clock_base *b,
>          ktime_t n);
>
>};
># 189 "include/linux/hrtimer.h"
>struct hrtimer_cpu_base {
> spinlock_t lock;
> struct hrtimer_clock_base clock_base[2];
> struct list_head cb_pending;
>
> ktime_t expires_next;
> int hres_active;
> unsigned long nr_events;
>
>};
>
>
>struct clock_event_device;
>
>extern void clock_was_set(void);
>extern void hres_timers_resume(void);
>extern void hrtimer_interrupt(struct clock_event_device *dev);
>
>
>
>
>static inline __attribute__((always_inline)) ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
>{
> return timer->base->get_time();
>}
>
>static inline __attribute__((always_inline)) int hrtimer_is_hres_active(struct hrtimer *timer)
>{
> return timer->base->cpu_base->hres_active;
>}
># 260 "include/linux/hrtimer.h"
>extern ktime_t ktime_get(void);
>extern ktime_t ktime_get_real(void);
>
>
>
>
>extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
>    enum hrtimer_mode mode);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void hrtimer_init_on_stack(struct hrtimer *timer,
>      clockid_t which_clock,
>      enum hrtimer_mode mode)
>{
> hrtimer_init(timer, which_clock, mode);
>}
>static inline __attribute__((always_inline)) void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
>
>
>
>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);
>
>static inline __attribute__((always_inline)) int hrtimer_restart(struct hrtimer *timer)
>{
> return hrtimer_start(timer, timer->expires, HRTIMER_MODE_ABS);
>}
>
>
>extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
>extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
>
>extern ktime_t hrtimer_get_next_event(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_active(const struct hrtimer *timer)
>{
> return timer->state != 0x00;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_is_queued(struct hrtimer *timer)
>{
> return timer->state &
>  (0x01 | 0x04);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_callback_running(struct hrtimer *timer)
>{
> return timer->state & 0x02;
>}
>
>
>extern u64
>hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
>
>
>static inline __attribute__((always_inline)) u64 hrtimer_forward_now(struct hrtimer *timer,
>          ktime_t interval)
>{
> return hrtimer_forward(timer, timer->base->get_time(), 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 hrtimer_run_pending(void);
>
>
>extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) hrtimers_init(void);
># 363 "include/linux/hrtimer.h"
>extern void sysrq_timer_list_show(void);
># 393 "include/linux/hrtimer.h"
>static inline __attribute__((always_inline)) void timer_stats_account_hrtimer(struct hrtimer *timer)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
>{
>}
># 87 "include/linux/sched.h" 2
>
># 1 "include/linux/task_io_accounting.h" 1
># 35 "include/linux/task_io_accounting.h"
>struct task_io_accounting {
>};
># 88 "include/linux/sched.h" 2
>
>
># 1 "include/linux/latencytop.h" 1
># 33 "include/linux/latencytop.h"
>static inline __attribute__((always_inline)) void
>account_scheduler_latency(struct task_struct *task, int usecs, int inter)
>{
>}
>
>static inline __attribute__((always_inline)) void clear_all_latency_tracing(struct task_struct *p)
>{
>}
># 90 "include/linux/sched.h" 2
>
>
>
>struct mem_cgroup;
>struct exec_domain;
>struct futex_pi_state;
>struct robust_list_head;
>struct bio;
># 115 "include/linux/sched.h"
>extern unsigned long avenrun[];
># 129 "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);
>
>struct seq_file;
>struct cfs_rq;
>struct task_group;
>
>extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
>extern void proc_sched_set_task(struct task_struct *p);
>extern void
>print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
># 161 "include/linux/sched.h"
>extern unsigned long long time_sync_thresh;
># 238 "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 schedule_tail(struct task_struct *prev);
>extern void init_idle(struct task_struct *idle, int cpu);
>extern void init_idle_bootup_task(struct task_struct *idle);
>
>extern cpumask_t nohz_cpu_mask;
>
>
>
>static inline __attribute__((always_inline)) int select_nohz_load_balancer(int cpu)
>{
> return 0;
>}
>
>
>extern unsigned long rt_needs_cpu(int cpu);
>
>
>
>
>extern void show_state_filter(unsigned long state_filter);
>
>static inline __attribute__((always_inline)) void show_state(void)
>{
> show_state_filter(0);
>}
>
>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 account_process_tick(struct task_struct *task, int user);
>extern void update_process_times(int user);
>extern void scheduler_tick(void);
>extern void hrtick_resched(void);
>
>extern void sched_show_task(struct task_struct *p);
>
>
>extern void softlockup_tick(void);
>extern void spawn_softlockup_task(void);
>extern void touch_softlockup_watchdog(void);
>extern void touch_all_softlockup_watchdogs(void);
>extern unsigned long softlockup_thresh;
>extern unsigned long sysctl_hung_task_check_count;
>extern unsigned long sysctl_hung_task_timeout_secs;
>extern unsigned long sysctl_hung_task_warnings;
># 321 "include/linux/sched.h"
>extern char __sched_text_start[], __sched_text_end[];
>
>
>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_killable(signed long timeout);
>extern signed long schedule_timeout_uninterruptible(signed long timeout);
> void schedule(void);
>
>struct nsproxy;
>struct user_namespace;
>
>
>
>
>extern int sysctl_max_map_count;
>
>
># 1 "include/linux/aio.h" 1
>
>
>
>
>
># 1 "include/linux/workqueue.h" 1
># 14 "include/linux/workqueue.h"
>struct workqueue_struct;
>
>struct work_struct;
>typedef void (*work_func_t)(struct work_struct *work);
>
>
>
>
>
>
>
>struct work_struct {
> atomic_long_t data;
>
>
>
> struct list_head entry;
> work_func_t func;
>
>
>
>};
>
>
>
>struct delayed_work {
> struct work_struct work;
> struct timer_list timer;
>};
>
>struct execute_work {
> struct work_struct work;
>};
># 150 "include/linux/workqueue.h"
>extern struct workqueue_struct *
>__create_workqueue_key(const char *name, int singlethread,
>         int freezeable, struct lock_class_key *key,
>         const char *lock_name);
># 179 "include/linux/workqueue.h"
>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 delayed_work *work, unsigned long delay);
>extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
>   struct delayed_work *work, unsigned long delay);
>
>extern void flush_workqueue(struct workqueue_struct *wq);
>extern void flush_scheduled_work(void);
>
>extern int schedule_work(struct work_struct *work);
>extern int schedule_delayed_work(struct delayed_work *work, unsigned long delay);
>extern int schedule_delayed_work_on(int cpu, struct delayed_work *work,
>     unsigned long delay);
>extern int schedule_on_each_cpu(work_func_t func);
>extern int current_is_keventd(void);
>extern int keventd_up(void);
>
>extern void init_workqueues(void);
>int execute_in_process_context(work_func_t fn, struct execute_work *);
>
>extern int cancel_work_sync(struct work_struct *work);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int cancel_delayed_work(struct delayed_work *work)
>{
> int ret;
>
> ret = del_timer(&work->timer);
> if (ret)
>  clear_bit(0, ((unsigned long *)(&(&work->work)->data)));
> return ret;
>}
>
>extern int cancel_delayed_work_sync(struct delayed_work *work);
>
>
>static inline __attribute__((always_inline))
>void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
>     struct delayed_work *work)
>{
> cancel_delayed_work_sync(work);
>}
>
>
>static inline __attribute__((always_inline))
>void cancel_rearming_delayed_work(struct delayed_work *work)
>{
> cancel_delayed_work_sync(work);
>}
># 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,
>};
># 57 "include/linux/aio_abi.h"
>struct io_event {
> __u64 data;
> __u64 obj;
> __s64 res;
> __s64 res2;
>};
># 78 "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;
>
>
> __u32 aio_flags;
>
>
>
>
>
> __u32 aio_resfd;
>};
># 7 "include/linux/aio.h" 2
>
># 1 "include/linux/uio.h" 1
># 16 "include/linux/uio.h"
>struct iovec
>{
> void *iov_base;
> __kernel_size_t iov_len;
>};
>
>
>
>struct kvec {
> void *iov_base;
> size_t iov_len;
>};
># 45 "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;
> unsigned 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;
> struct iovec ki_inline_vec;
>  struct iovec *ki_iovec;
>  unsigned long ki_nr_segs;
>  unsigned long ki_cur_seg;
>
> struct list_head ki_list;
>
>
>
>
>
>
> struct file *ki_eventfd;
>};
># 149 "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 delayed_work 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);
>struct mm_struct;
>extern void exit_aio(struct mm_struct *mm);
>
>
>
>
>
>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;
># 342 "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);
># 389 "include/linux/sched.h"
>extern void set_dumpable(struct mm_struct *mm, int value);
>extern int get_dumpable(struct mm_struct *mm);
># 411 "include/linux/sched.h"
>struct sighand_struct {
> atomic_t count;
> struct k_sigaction action[64];
> spinlock_t siglock;
> wait_queue_head_t signalfd_wqh;
>};
>
>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;
>};
># 433 "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 pid *leader_pid;
> ktime_t it_real_incr;
>
>
> cputime_t it_prof_expires, it_virt_expires;
> cputime_t it_prof_incr, it_virt_incr;
># 478 "include/linux/sched.h"
> union {
>  pid_t pgrp __attribute__((deprecated));
>  pid_t __pgrp;
> };
>
> struct pid *tty_old_pgrp;
>
> union {
>  pid_t session __attribute__((deprecated));
>  pid_t __session;
> };
>
>
> int leader;
>
> struct tty_struct *tty;
>
>
>
>
>
>
>
> cputime_t utime, stime, cutime, cstime;
> cputime_t gtime;
> cputime_t cgtime;
> unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
> unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
> unsigned long inblock, oublock, cinblock, coublock;
>
>
>
>
>
>
>
> unsigned long long sum_sched_runtime;
># 525 "include/linux/sched.h"
> struct rlimit rlim[16];
>
> struct list_head cpu_timers[3];
># 536 "include/linux/sched.h"
> struct pacct_struct pacct;
># 545 "include/linux/sched.h"
>};
># 569 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int signal_group_exit(const struct signal_struct *sig)
>{
> return (sig->flags & 0x00000008) ||
>  (sig->group_exit_task != ((void *)0));
>}
>
>
>
>
>struct user_struct {
> atomic_t __count;
> atomic_t processes;
> atomic_t files;
> atomic_t sigpending;
>
> atomic_t inotify_watches;
> atomic_t inotify_devs;
>
>
>
> unsigned long mq_bytes;
>
> unsigned long locked_shm;
>
>
>
>
>
>
>
> struct hlist_node uidhash_node;
> uid_t uid;
># 609 "include/linux/sched.h"
>};
>
>extern int uids_sysfs_init(void);
>
>extern struct user_struct *find_user(uid_t);
>
>extern struct user_struct root_user;
>
>
>struct backing_dev_info;
>struct reclaim_state;
># 672 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int sched_info_on(void)
>{
>
>
>
>
>
>
> return 0;
>
>}
>
>enum cpu_idle_type {
> CPU_IDLE,
> CPU_NOT_IDLE,
> CPU_NEWLY_IDLE,
> CPU_MAX_IDLE_TYPES
>};
># 832 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int above_background_load(void)
>{
> unsigned long cpu;
>
> for (((cpu)) = 0; ((cpu)) < 1; ((cpu))++, (void)cpu_online_map) {
>  if (weighted_cpuload(cpu) >= (1L << 10))
>   return 1;
> }
> return 0;
>}
>
>struct io_context;
>
>
>struct group_info {
> int ngroups;
> atomic_t usage;
> gid_t small_block[32];
> int nblocks;
> gid_t *blocks[0];
>};
># 869 "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;
>
>struct rq;
>struct sched_domain;
>
>struct sched_class {
> const struct sched_class *next;
>
> void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
> void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
> void (*yield_task) (struct rq *rq);
> int (*select_task_rq)(struct task_struct *p, int sync);
>
> void (*check_preempt_curr) (struct rq *rq, struct task_struct *p);
>
> struct task_struct * (*pick_next_task) (struct rq *rq);
> void (*put_prev_task) (struct rq *rq, struct task_struct *p);
># 918 "include/linux/sched.h"
> void (*set_curr_task) (struct rq *rq);
> void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
> void (*task_new) (struct rq *rq, struct task_struct *p);
> void (*set_cpus_allowed)(struct task_struct *p,
>     const cpumask_t *newmask);
>
> void (*join_domain)(struct rq *rq);
> void (*leave_domain)(struct rq *rq);
>
> void (*switched_from) (struct rq *this_rq, struct task_struct *task,
>          int running);
> void (*switched_to) (struct rq *this_rq, struct task_struct *task,
>        int running);
> void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
>        int oldprio, int running);
>
>
>
>
>};
>
>struct load_weight {
> unsigned long weight, inv_weight;
>};
># 953 "include/linux/sched.h"
>struct sched_entity {
> struct load_weight load;
> struct rb_node run_node;
> struct list_head group_node;
> unsigned int on_rq;
>
> u64 exec_start;
> u64 sum_exec_runtime;
> u64 vruntime;
> u64 prev_sum_exec_runtime;
>
> u64 last_wakeup;
> u64 avg_overlap;
># 1008 "include/linux/sched.h"
>};
>
>struct sched_rt_entity {
> struct list_head run_list;
> unsigned int time_slice;
> unsigned long timeout;
> int nr_cpus_allowed;
>
> struct sched_rt_entity *back;
>
>
>
>
>
>
>
>};
>
>struct task_struct {
> volatile long state;
> void *stack;
> atomic_t usage;
> unsigned int flags;
> unsigned int ptrace;
>
> int lock_depth;
>
>
>
>
>
>
>
> int prio, static_prio, normal_prio;
> const struct sched_class *sched_class;
> struct sched_entity se;
> struct sched_rt_entity rt;
># 1059 "include/linux/sched.h"
> unsigned char fpu_counter;
> s8 oomkilladj;
>
>
>
>
> unsigned int policy;
> cpumask_t cpus_allowed;
># 1077 "include/linux/sched.h"
> struct list_head tasks;
>
>
>
>
> struct list_head ptrace_children;
> struct list_head ptrace_list;
>
> struct mm_struct *mm, *active_mm;
>
>
> struct linux_binfmt *binfmt;
> int exit_state;
> int exit_code, exit_signal;
> int pdeath_signal;
>
> unsigned int personality;
> unsigned did_exec:1;
> pid_t pid;
> pid_t tgid;
># 1107 "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 int rt_priority;
> cputime_t utime, stime, utimescaled, stimescaled;
> cputime_t gtime;
> cputime_t prev_utime, prev_stime;
> unsigned long nvcsw, nivcsw;
> struct timespec start_time;
> struct timespec real_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, cap_bset;
> unsigned securebits;
> struct user_struct *user;
>
>
>
>
>
> char comm[16];
>
>
>
>
> int link_count, total_link_count;
>
>
> struct sysv_sem sysvsem;
>
>
>
> unsigned long last_switch_timestamp;
> unsigned long last_switch_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;
>
>
>
> 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;
># 1241 "include/linux/sched.h"
> void *journal_info;
>
>
> struct bio *bio_list, **bio_tail;
>
>
> 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;
>
>
>
>
> struct task_io_accounting ioac;
># 1281 "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;
>
>
>
>
>
>
> struct prop_local_single dirties;
>
>
>
>
>};
># 1327 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int rt_prio(int prio)
>{
> if (__builtin_expect(!!(prio < 100), 0))
>  return 1;
> return 0;
>}
>
>static inline __attribute__((always_inline)) int rt_task(struct task_struct *p)
>{
> return rt_prio(p->prio);
>}
>
>static inline __attribute__((always_inline)) void set_task_session(struct task_struct *tsk, pid_t session)
>{
> tsk->signal->__session = session;
>}
>
>static inline __attribute__((always_inline)) void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
>{
> tsk->signal->__pgrp = 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;
>}
>
>struct pid_namespace;
># 1385 "include/linux/sched.h"
>static inline __attribute__((always_inline)) pid_t task_pid_nr(struct task_struct *tsk)
>{
> return tsk->pid;
>}
>
>pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_pid_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_pid(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_tgid_nr(struct task_struct *tsk)
>{
> return tsk->tgid;
>}
>
>pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_tgid_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_tgid(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_pgrp_nr(struct task_struct *tsk)
>{
> return tsk->signal->__pgrp;
>}
>
>pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_pgrp_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_pgrp(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_session_nr(struct task_struct *tsk)
>{
> return tsk->signal->__session;
>}
>
>pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_session_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_session(tsk));
>}
># 1445 "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_global_init(struct task_struct *tsk)
>{
> return tsk->pid == 1;
>}
>
>
>
>
>
>extern int is_container_init(struct task_struct *tsk);
>
>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_dec_and_test(&t->usage))
>  __put_task_struct(t);
>}
># 1540 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int set_cpus_allowed_ptr(struct task_struct *p,
>           const cpumask_t *new_mask)
>{
> if (!(__builtin_constant_p(((0))) ? constant_test_bit(((0)), ((*new_mask).bits)) : variable_test_bit(((0)), ((*new_mask).bits))))
>  return -22;
> return 0;
>}
>
>static inline __attribute__((always_inline)) int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
>{
> return set_cpus_allowed_ptr(p, &new_mask);
>}
>
>extern unsigned long long sched_clock(void);
>
>
>static inline __attribute__((always_inline)) void sched_clock_init(void)
>{
>}
>
>static inline __attribute__((always_inline)) u64 sched_clock_cpu(int cpu)
>{
> return sched_clock();
>}
>
>static inline __attribute__((always_inline)) void sched_clock_tick(void)
>{
>}
>
>static inline __attribute__((always_inline)) void sched_clock_idle_sleep_event(void)
>{
>}
>
>static inline __attribute__((always_inline)) void sched_clock_idle_wakeup_event(u64 delta_ns)
>{
>}
># 1588 "include/linux/sched.h"
>extern unsigned long long cpu_clock(int cpu);
>
>extern unsigned long long
>task_sched_runtime(struct task_struct *task);
># 1600 "include/linux/sched.h"
>extern void sched_clock_idle_sleep_event(void);
>extern void sched_clock_idle_wakeup_event(u64 delta_ns);
>
>
>
>
>static inline __attribute__((always_inline)) void idle_task_exit(void) {}
>
>
>extern void sched_idle_next(void);
>
>
>
>
>static inline __attribute__((always_inline)) void wake_up_idle_cpu(int cpu) { }
>
>
>
>extern unsigned int sysctl_sched_latency;
>extern unsigned int sysctl_sched_min_granularity;
>extern unsigned int sysctl_sched_wakeup_granularity;
>extern unsigned int sysctl_sched_child_runs_first;
>extern unsigned int sysctl_sched_features;
>extern unsigned int sysctl_sched_migration_cost;
>extern unsigned int sysctl_sched_nr_migrate;
>
>int sched_nr_latency_handler(struct ctl_table *table, int write,
>  struct file *file, void *buffer, size_t *length,
>  loff_t *ppos);
>
>extern unsigned int sysctl_sched_rt_period;
>extern int sysctl_sched_rt_runtime;
>
>int sched_rt_handler(struct ctl_table *table, int write,
>  struct file *filp, void *buffer, size_t *lenp,
>  loff_t *ppos);
>
>extern unsigned int sysctl_sched_compat_yield;
>
>
>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);
># 1651 "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[((1 << 1) * ((1UL) << 12))/sizeof(long)];
>};
>
>
>static inline __attribute__((always_inline)) int kstack_end(void *addr)
>{
>
>
>
> return !(((unsigned long)addr+sizeof(void*)-1) & (((1 << 1) * ((1UL) << 12))-sizeof(void*)));
>}
>
>
>extern union thread_union init_thread_union;
>extern struct task_struct init_task;
>
>extern struct mm_struct init_mm;
>
>extern struct pid_namespace init_pid_ns;
># 1707 "include/linux/sched.h"
>extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
>  struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) struct task_struct *__attribute__((deprecated)) find_task_by_pid(pid_t nr)
>{
> return find_task_by_pid_type_ns(PIDTYPE_PID, nr, &init_pid_ns);
>}
>extern struct task_struct *find_task_by_vpid(pid_t nr);
>extern struct task_struct *find_task_by_pid_ns(pid_t nr,
>  struct pid_namespace *ns);
>
>extern void __set_special_pids(struct pid *pid);
>
>
>extern struct user_struct * alloc_uid(struct user_namespace *, 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 release_uids(struct user_namespace *ns);
>
>
>
>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_dead(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 ignore_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 { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (0); } while (0);
> ret = dequeue_signal(tsk, mask, info);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } 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 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_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_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_proc(pid_t, int, int);
>extern struct sigqueue *sigqueue_alloc(void);
>extern void sigqueue_free(struct sigqueue *);
>extern int send_sigqueue(struct sigqueue *, struct task_struct *, int group);
>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 - (current_thread_info()->task)->sas_ss_sp < (current_thread_info()->task)->sas_ss_size);
>}
>
>static inline __attribute__((always_inline)) int sas_ss_flags(unsigned long sp)
>{
> return ((current_thread_info()->task)->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 (__builtin_expect(!!(atomic_dec_and_test(&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 struct mm_struct *dup_mm(struct task_struct *tsk);
>
>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 flush_itimer_signals(void);
>
>extern void do_group_exit(int);
>
>extern void daemonize(const char *, ...);
>extern int allow_signal(int);
>extern int disallow_signal(int);
>
>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 char *get_task_comm(char *to, struct task_struct *tsk);
># 1900 "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))
>int same_thread_group(struct task_struct *p1, struct task_struct *p2)
>{
> return p1->tgid == p2->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 = (*(volatile typeof(p->thread_group.next) *)&(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);
>}
># 1935 "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 { ({ unsigned long __dummy; typeof(*flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(*flags); } 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)
>{
> *((struct thread_info *)(p)->stack) = *((struct thread_info *)(org)->stack);
> ((struct thread_info *)(p)->stack)->task = p;
>}
>
>static inline __attribute__((always_inline)) unsigned long *end_of_stack(struct task_struct *p)
>{
> return (unsigned long *)(((struct thread_info *)(p)->stack) + 1);
>}
>
>
>
>extern void thread_info_cache_init(void);
>
>
>
>
>static inline __attribute__((always_inline)) void set_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> set_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> clear_ti_thread_flag(((struct thread_info *)(tsk)->stack), 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(((struct thread_info *)(tsk)->stack), 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(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) int test_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) void set_tsk_need_resched(struct task_struct *tsk)
>{
> set_tsk_thread_flag(tsk,2);
>}
>
>static inline __attribute__((always_inline)) void clear_tsk_need_resched(struct task_struct *tsk)
>{
> clear_tsk_thread_flag(tsk,2);
>}
>
>static inline __attribute__((always_inline)) int test_tsk_need_resched(struct task_struct *tsk)
>{
> return __builtin_expect(!!(test_tsk_thread_flag(tsk,2)), 0);
>}
>
>static inline __attribute__((always_inline)) int signal_pending(struct task_struct *p)
>{
> return __builtin_expect(!!(test_tsk_thread_flag(p,1)), 0);
>}
>
>extern int __fatal_signal_pending(struct task_struct *p);
>
>static inline __attribute__((always_inline)) int fatal_signal_pending(struct task_struct *p)
>{
> return signal_pending(p) && __fatal_signal_pending(p);
>}
>
>static inline __attribute__((always_inline)) int need_resched(void)
>{
> return __builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 2)), 0);
>}
># 2041 "include/linux/sched.h"
>extern int _cond_resched(void);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int cond_resched(void)
>{
> return _cond_resched();
>}
>
>extern int cond_resched_lock(spinlock_t * lock);
>extern int cond_resched_softirq(void);
>static inline __attribute__((always_inline)) int cond_resched_bkl(void)
>{
> return _cond_resched();
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int spin_needbreak(spinlock_t *lock)
>{
>
>
>
> return 0;
>
>}
>
>
>
>
>
>
>
>extern void recalc_sigpending_and_wake(struct task_struct *t);
>extern void recalc_sigpending(void);
>
>extern void signal_wake_up(struct task_struct *t, int resume_stopped);
># 2099 "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 = (0x40000000);
> mm->get_unmapped_area = arch_get_unmapped_area;
> mm->unmap_area = arch_unmap_area;
>}
>
>
>extern long sched_setaffinity(pid_t pid, const cpumask_t *new_mask);
>extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
>
>extern int sched_mc_power_savings, sched_smt_power_savings;
>
>extern void normalize_rt_tasks(void);
># 2173 "include/linux/sched.h"
>static inline __attribute__((always_inline)) void add_rchar(struct task_struct *tsk, ssize_t amt)
>{
>}
>
>static inline __attribute__((always_inline)) void add_wchar(struct task_struct *tsk, ssize_t amt)
>{
>}
>
>static inline __attribute__((always_inline)) void inc_syscr(struct task_struct *tsk)
>{
>}
>
>static inline __attribute__((always_inline)) void inc_syscw(struct task_struct *tsk)
>{
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void migration_init(void)
>{
>}
># 2206 "include/linux/sched.h"
>static inline __attribute__((always_inline)) void mm_update_next_owner(struct mm_struct *mm)
>{
>}
>
>static inline __attribute__((always_inline)) void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
>{
>}
># 8 "include/linux/nmi.h" 2
>
># 1 "include/asm/irq.h" 1
># 9 "include/linux/nmi.h" 2
># 23 "include/linux/nmi.h"
>static inline __attribute__((always_inline)) void touch_nmi_watchdog(void)
>{
> touch_softlockup_watchdog();
>}
>static inline __attribute__((always_inline)) void acpi_nmi_disable(void) { }
>static inline __attribute__((always_inline)) void acpi_nmi_enable(void) { }
># 32 "kernel/sched.c" 2
>
>
># 1 "include/linux/uaccess.h" 1
># 16 "include/linux/uaccess.h"
>static inline __attribute__((always_inline)) void pagefault_disable(void)
>{
> do { (current_thread_info()->preempt_count) += (1); } while (0);
>
>
>
>
> __asm__ __volatile__("": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void pagefault_enable(void)
>{
>
>
>
>
> __asm__ __volatile__("": : :"memory");
> do { (current_thread_info()->preempt_count) -= (1); } while (0);
>
>
>
> __asm__ __volatile__("": : :"memory");
> do { } while (0);
>}
>
>
>
>static inline __attribute__((always_inline)) unsigned long __copy_from_user_inatomic_nocache(void *to,
>    const void *from, unsigned long n)
>{
> return copy_from_user(to, from, n);
>}
>
>static inline __attribute__((always_inline)) unsigned long __copy_from_user_nocache(void *to,
>    const void *from, unsigned long n)
>{
> return copy_from_user(to, from, n);
>}
># 96 "include/linux/uaccess.h"
>extern long probe_kernel_read(void *dst, void *src, size_t size);
># 107 "include/linux/uaccess.h"
>extern long probe_kernel_write(void *dst, void *src, size_t size);
># 34 "kernel/sched.c" 2
>
># 1 "include/linux/highmem.h" 1
>
>
>
>
># 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/arch/ioctl.h" 1
>
># 1 "include/asm-generic/ioctl.h" 1
># 72 "include/asm-generic/ioctl.h"
>extern unsigned int __invalid_size_argument_for_IOC;
># 1 "include/asm/arch/ioctl.h" 2
># 5 "include/asm/ioctl.h" 2
># 5 "include/linux/ioctl.h" 2
># 11 "include/linux/fs.h" 2
># 24 "include/linux/fs.h"
>extern int sysctl_nr_open;
># 36 "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;
>
>
>extern int dir_notify_enable;
># 277 "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;
>}
># 278 "include/linux/fs.h" 2
>
># 1 "include/linux/dcache.h" 1
># 10 "include/linux/dcache.h"
>struct nameidata;
>struct path;
>struct vfsmount;
># 32 "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 *);
> char *(*d_dname)(struct dentry *, char *, int);
>};
># 179 "include/linux/dcache.h"
>extern spinlock_t dcache_lock;
>extern seqlock_t rename_lock;
># 198 "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 *);
># 263 "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);
>}
># 277 "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 *dynamic_dname(struct dentry *, char *, int, const char *, ...);
>
>extern char *__d_path(const struct path *path, struct path *root, char *, int);
>extern char *d_path(struct path *, char *, int);
>extern char *dentry_path(struct dentry *, char *, int);
># 321 "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)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/dcache.h", 324, (__func__)); panic("BUG!"); } while (0); } while(0);
>  atomic_inc(&dentry->d_count);
> }
> return dentry;
>}
>
>extern struct dentry * dget_locked(struct dentry *);
># 339 "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 dentry *lookup_create(struct nameidata *nd, int is_dir);
>
>extern int sysctl_vfs_cache_pressure;
># 279 "include/linux/fs.h" 2
>
># 1 "include/linux/namei.h" 1
>
>
>
>
>
>
>
>struct vfsmount;
>
>struct open_intent {
> int flags;
> int create_mode;
> struct file *file;
>};
>
>enum { MAX_NESTED_LINKS = 8 };
>
>struct nameidata {
> struct path path;
> struct qstr last;
> unsigned int flags;
> int last_type;
> unsigned depth;
> char *saved_names[MAX_NESTED_LINKS + 1];
>
>
> union {
>  struct open_intent open;
> } intent;
>};
>
>
>
>
>enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
># 60 "include/linux/namei.h"
>extern int __user_walk(const char *, unsigned, struct nameidata *);
>extern int __user_walk_fd(int dfd, const char *, unsigned, struct nameidata *);
>
>
>
>
>extern int path_lookup(const char *, unsigned, struct nameidata *);
>extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
>      const char *, unsigned int, struct nameidata *);
>
>extern int __user_path_lookup_open(const char *, unsigned lookup_flags, struct nameidata *nd, int open_flags);
>extern int path_lookup_open(int dfd, const char *name, unsigned lookup_flags, struct nameidata *, int open_flags);
>extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
>  int (*open)(struct inode *, struct file *));
>extern struct file *nameidata_to_filp(struct nameidata *nd, int flags);
>extern void release_open_intent(struct nameidata *);
>
>extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
>extern struct dentry *lookup_one_noperm(const char *, struct dentry *);
>
>extern int follow_down(struct vfsmount **, struct dentry **);
>extern int follow_up(struct vfsmount **, struct dentry **);
>
>extern struct dentry *lock_rename(struct dentry *, struct dentry *);
>extern void unlock_rename(struct dentry *, struct dentry *);
>
>static inline __attribute__((always_inline)) void nd_set_link(struct nameidata *nd, char *path)
>{
> nd->saved_names[nd->depth] = path;
>}
>
>static inline __attribute__((always_inline)) char *nd_get_link(struct nameidata *nd)
>{
> return nd->saved_names[nd->depth];
>}
># 280 "include/linux/fs.h" 2
>
>
>
>
>
># 1 "include/linux/radix-tree.h" 1
># 41 "include/linux/radix-tree.h"
>static inline __attribute__((always_inline)) void *radix_tree_ptr_to_indirect(void *ptr)
>{
> return (void *)((unsigned long)ptr | 1);
>}
>
>static inline __attribute__((always_inline)) void *radix_tree_indirect_to_ptr(void *ptr)
>{
> return (void *)((unsigned long)ptr & ~1);
>}
>
>static inline __attribute__((always_inline)) int radix_tree_is_indirect_ptr(void *ptr)
>{
> return (int)((unsigned long)ptr & 1);
>}
>
>
>
>
>
>
>struct radix_tree_root {
> unsigned int height;
> gfp_t gfp_mask;
> struct radix_tree_node *rnode;
>};
># 134 "include/linux/radix-tree.h"
>static inline __attribute__((always_inline)) void *radix_tree_deref_slot(void **pslot)
>{
> void *ret = *pslot;
> if (__builtin_expect(!!(radix_tree_is_indirect_ptr(ret)), 0))
>  ret = ((void *)-1UL);
> return ret;
>}
># 149 "include/linux/radix-tree.h"
>static inline __attribute__((always_inline)) void radix_tree_replace_slot(void **pslot, void *item)
>{
> do { if (__builtin_expect(!!(radix_tree_is_indirect_ptr(item)), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/radix-tree.h", 151, (__func__)); panic("BUG!"); } while (0); } while(0);
> ({ if (!__builtin_constant_p(item) || ((item) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (*pslot) = (item); });
>}
>
>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);
>unsigned long radix_tree_next_hole(struct radix_tree_root *root,
>    unsigned long index, unsigned long max_scan);
>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);
>}
># 285 "include/linux/fs.h" 2
>
>
>
>
>
>
># 1 "include/linux/semaphore.h" 1
># 16 "include/linux/semaphore.h"
>struct semaphore {
> spinlock_t lock;
> unsigned int count;
> struct list_head wait_list;
>};
># 34 "include/linux/semaphore.h"
>static inline __attribute__((always_inline)) void sema_init(struct semaphore *sem, int val)
>{
> static struct lock_class_key __key;
> *sem = (struct semaphore) { .lock = (spinlock_t) { .raw_lock = { }, }, .count = val, .wait_list = { &((*sem).wait_list), &((*sem).wait_list) }, };
> do { (void)(&__key); } while (0);
>}
>
>
>
>
>extern void down(struct semaphore *sem);
>extern int __attribute__((warn_unused_result)) down_interruptible(struct semaphore *sem);
>extern int __attribute__((warn_unused_result)) down_killable(struct semaphore *sem);
>extern int __attribute__((warn_unused_result)) down_trylock(struct semaphore *sem);
>extern int __attribute__((warn_unused_result)) down_timeout(struct semaphore *sem, long jiffies);
>extern void up(struct semaphore *sem);
># 291 "include/linux/fs.h" 2
>
>
>
>
>struct export_operations;
>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"))) __attribute__((__cold__)) inode_init(void);
>extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) inode_init_early(void);
>extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) 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);
># 346 "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;
># 103 "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;
>};
># 124 "include/linux/quota.h"
>struct if_dqinfo {
> __u64 dqi_bgrace;
> __u64 dqi_igrace;
> __u32 dqi_flags;
> __u32 dqi_valid;
>};
># 142 "include/linux/quota.h"
>enum {
> QUOTA_NL_C_UNSPEC,
> QUOTA_NL_C_WARNING,
> __QUOTA_NL_C_MAX,
>};
>
>
>enum {
> QUOTA_NL_A_UNSPEC,
> QUOTA_NL_A_QTYPE,
> QUOTA_NL_A_EXCESS_ID,
> QUOTA_NL_A_WARNING,
> QUOTA_NL_A_DEV_MAJOR,
> QUOTA_NL_A_DEV_MINOR,
> QUOTA_NL_A_CAUSED_ID,
> __QUOTA_NL_A_MAX,
>};
># 169 "include/linux/quota.h"
>
># 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;
># 170 "include/linux/quota.h" 2
>
># 1 "include/linux/dqblk_v1.h" 1
># 21 "include/linux/dqblk_v1.h"
>struct v1_mem_dqinfo {
>};
># 171 "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;
>};
># 172 "include/linux/quota.h" 2
>
>
>
>extern spinlock_t dq_data_lock;
># 187 "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;
> int dqi_fmt_id;
>
> struct list_head dqi_dirty_list;
> unsigned long dqi_flags;
> unsigned int dqi_bgrace;
> unsigned int dqi_igrace;
> qsize_t dqi_maxblimit;
> qsize_t dqi_maxilimit;
> 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;
># 253 "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);
> int (*quota_off)(struct super_block *, int, 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;
>};
># 330 "include/linux/quota.h"
>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];
>};
># 353 "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;
>};
># 368 "include/linux/fs.h" 2
># 395 "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 iov_iter {
> const struct iovec *iov;
> unsigned long nr_segs;
> size_t iov_offset;
> size_t count;
>};
>
>size_t iov_iter_copy_from_user_atomic(struct page *page,
>  struct iov_iter *i, unsigned long offset, size_t bytes);
>size_t iov_iter_copy_from_user(struct page *page,
>  struct iov_iter *i, unsigned long offset, size_t bytes);
>void iov_iter_advance(struct iov_iter *i, size_t bytes);
>int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
>size_t iov_iter_single_seg_count(struct iov_iter *i);
>
>static inline __attribute__((always_inline)) void iov_iter_init(struct iov_iter *i,
>   const struct iovec *iov, unsigned long nr_segs,
>   size_t count, size_t written)
>{
> i->iov = iov;
> i->nr_segs = nr_segs;
> i->iov_offset = 0;
> i->count = count + written;
>
> iov_iter_advance(i, written);
>}
>
>static inline __attribute__((always_inline)) size_t iov_iter_count(struct iov_iter *i)
>{
> return i->count;
>}
>
>
>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);
>
> int (*write_begin)(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned flags,
>    struct page **pagep, void **fsdata);
> int (*write_end)(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned copied,
>    struct page *page, void *fsdata);
>
>
> 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);
> int (*get_xip_mem)(struct address_space *, unsigned long, int,
>      void **, unsigned long *);
>
> int (*migratepage) (struct address_space *,
>   struct page *, struct page *);
> int (*launder_page) (struct page *);
>};
>
>
>
>
>
>int pagecache_write_begin(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned flags,
>    struct page **pagep, void **fsdata);
>
>int pagecache_write_end(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned copied,
>    struct page *page, void *fsdata);
>
>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 semaphore bd_mount_sem;
> 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;
>};
># 559 "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;
>}
># 592 "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;
> unsigned int i_nlink;
> uid_t i_uid;
> gid_t i_gid;
> dev_t i_rdev;
> u64 i_version;
> loff_t i_size;
>
>
>
> struct timespec i_atime;
> struct timespec i_mtime;
> struct timespec i_ctime;
> unsigned int i_blkbits;
> blkcnt_t i_blocks;
> unsigned short i_bytes;
> umode_t i_mode;
> spinlock_t i_lock;
> struct mutex i_mutex;
> struct rw_semaphore i_alloc_sem;
> const 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 dquot *i_dquot[2];
>
> 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;
>
>
> unsigned long i_dnotify_mask;
> struct dnotify_struct *i_dnotify;
>
>
>
> struct list_head inotify_watches;
> struct mutex inotify_mutex;
>
>
> unsigned long i_state;
> unsigned long dirtied_when;
>
> unsigned int i_flags;
>
> atomic_t i_writecount;
>
>
>
> void *i_private;
>};
># 670 "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);
># 692 "include/linux/fs.h"
>static inline __attribute__((always_inline)) loff_t i_size_read(const struct inode *inode)
>{
># 711 "include/linux/fs.h"
> return inode->i_size;
>
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void i_size_write(struct inode *inode, loff_t i_size)
>{
># 731 "include/linux/fs.h"
> inode->i_size = i_size;
>
>}
>
>static inline __attribute__((always_inline)) unsigned iminor(const struct inode *inode)
>{
> return ((unsigned int) ((inode->i_rdev) & ((1U << 20) - 1)));
>}
>
>static inline __attribute__((always_inline)) unsigned imajor(const 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 int size;
> unsigned int async_size;
>
>
> unsigned int ra_pages;
> int mmap_miss;
> loff_t prev_pos;
>};
>
>
>
>
>static inline __attribute__((always_inline)) int ra_has_index(struct file_ra_state *ra, unsigned long index)
>{
> return (index >= ra->start &&
>  index < ra->start + ra->size);
>}
>
>
>
>
>struct file {
>
>
>
>
> union {
>  struct list_head fu_list;
>  struct rcu_head fu_rcuhead;
> } f_u;
> struct path f_path;
>
>
> 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;
>
> u64 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;
># 859 "include/linux/fs.h"
>static inline __attribute__((always_inline)) void file_take_write(struct file *filp) {}
>static inline __attribute__((always_inline)) void file_release_write(struct file *filp) {}
>static inline __attribute__((always_inline)) void file_reset_write(struct file *filp) {}
>static inline __attribute__((always_inline)) void file_check_state(struct file *filp) {}
>static inline __attribute__((always_inline)) int file_check_writeable(struct file *filp)
>{
> return 0;
>}
># 894 "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 *);
> int (*fl_grant)(struct file_lock *, struct file_lock *, int);
> 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
>};
># 102 "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;
>};
># 916 "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;
> struct pid *fl_nspid;
> 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;
>  struct {
>   struct list_head link;
>   int state;
>  } afs;
> } fl_u;
>};
># 953 "include/linux/fs.h"
>
># 1 "include/linux/fcntl.h" 1
>
>
>
>
># 1 "include/asm/fcntl.h" 1
>
>
>
>
># 1 "include/asm/arch/fcntl.h" 1
>
># 1 "include/asm-generic/fcntl.h" 1
># 117 "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;
>
>};
># 1 "include/asm/arch/fcntl.h" 2
># 5 "include/asm/fcntl.h" 2
># 5 "include/linux/fcntl.h" 2
># 954 "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 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_mapping_range(struct address_space *mapping, 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_copy_lock(struct file_lock *, const struct file_lock *);
>extern void locks_remove_posix(struct file *, fl_owner_t);
>extern void locks_remove_flock(struct file *);
>extern void posix_test_lock(struct file *, struct file_lock *);
>extern int posix_lock_file(struct file *, struct file_lock *, 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 vfs_test_lock(struct file *, struct file_lock *);
>extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
>extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
>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 generic_setlease(struct file *, long, struct file_lock **);
>extern int vfs_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);
>extern struct seq_operations locks_seq_operations;
>
>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);
># 1026 "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;
> const struct super_operations *s_op;
> struct dquot_operations *dq_op;
>  struct quotactl_ops *s_qcop;
> const 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 list_head s_more_io;
> struct hlist_head s_anon;
> struct list_head s_files;
>
> struct block_device *s_bdev;
> struct mtd_info *s_mtd;
> 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;
>
>
>
>
>
> char *s_subtype;
>
>
>
>
>
> char *s_options;
>};
>
>extern struct timespec current_fs_time(struct super_block *sb);
>
>
>
>
>enum {
> SB_UNFROZEN = 0,
> SB_FREEZE_WRITE = 1,
> SB_FREEZE_TRANS = 2,
>};
># 1120 "include/linux/fs.h"
>extern void lock_super(struct super_block *);
>extern void unlock_super(struct super_block *);
>
>
>
>
>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);
># 1165 "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,
>      void **, unsigned long *);
> int (*media_changed) (struct gendisk *);
> int (*revalidate_disk) (struct gendisk *);
> int (*getgeo)(struct block_device *, struct hd_geometry *);
> struct module *owner;
>};
># 1198 "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);
># 1221 "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 (*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);
> int (*setlease)(struct file *, long, struct file_lock **);
>};
>
>struct inode_operations {
> int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
> struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
> int (*link) (struct dentry *,struct inode *,struct dentry *);
> int (*unlink) (struct inode *,struct dentry *);
> int (*symlink) (struct inode *,struct dentry *,const char *);
> int (*mkdir) (struct inode *,struct dentry *,int);
> int (*rmdir) (struct inode *,struct dentry *);
> int (*mknod) (struct inode *,struct dentry *,int,dev_t);
> int (*rename) (struct inode *, struct dentry *,
>   struct inode *, struct dentry *);
> int (*readlink) (struct dentry *, char *,int);
> 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);
> long (*fallocate)(struct inode *inode, int mode, loff_t offset,
>     loff_t len);
>};
>
>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 (*dirty_inode) (struct inode *);
> int (*write_inode) (struct inode *, int);
> 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 super_block *);
>
> int (*show_options)(struct seq_file *, struct vfsmount *);
> int (*show_stats)(struct seq_file *, struct vfsmount *);
>
> ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
> ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
>
>};
># 1385 "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);
>}
># 1404 "include/linux/fs.h"
>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);
>}
># 1426 "include/linux/fs.h"
>static inline __attribute__((always_inline)) void drop_nlink(struct inode *inode)
>{
> inode->i_nlink--;
>}
># 1439 "include/linux/fs.h"
>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);
>}
># 1458 "include/linux/fs.h"
>static inline __attribute__((always_inline)) void inode_inc_iversion(struct inode *inode)
>{
>       do { do { } while (0); (void)0; (void)(&inode->i_lock); } while (0);
>       inode->i_version++;
>       do { do { } while (0); (void)0; (void)(&inode->i_lock); } while (0);
>}
>
>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_path.mnt, file->f_path.dentry);
>}
>
>int sync_inode(struct inode *inode, struct writeback_control *wbc);
>
>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;
>
> struct lock_class_key i_lock_key;
> struct lock_class_key i_mutex_key;
> struct lock_class_key i_mutex_dir_key;
> struct lock_class_key i_alloc_sem_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 *,
> const struct super_operations *ops, unsigned long,
> struct vfsmount *mnt);
>extern int simple_set_mnt(struct vfsmount *mnt, 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_data(struct file_system_type *, void *data);
>
>extern int may_umount_tree(struct vfsmount *);
>extern int may_umount(struct vfsmount *);
>extern long do_mount(char *, char *, char *, unsigned long, void *);
>extern struct vfsmount *collect_mounts(struct vfsmount *, struct dentry *);
>extern void drop_collected_mounts(struct vfsmount *);
>
>extern int vfs_statfs(struct dentry *, struct kstatfs *);
>
>
>extern struct kobject *fs_kobj;
>
>
>
>
>extern int locks_mandatory_locked(struct inode *);
>extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int __mandatory_lock(struct inode *ino)
>{
> return (ino->i_mode & (0002000 | 00010)) == 0002000;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int mandatory_lock(struct inode *ino)
>{
> return ((ino)->i_sb->s_flags & (64)) && __mandatory_lock(ino);
>}
>
>static inline __attribute__((always_inline)) int locks_verify_locked(struct inode *inode)
>{
> if (mandatory_lock(inode))
>  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 && mandatory_lock(inode))
>  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 dfd, 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"))) __attribute__((__cold__)) vfs_caches_init_early(void);
>extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) vfs_caches_init(unsigned long);
>
>extern struct kmem_cache *names_cachep;
># 1625 "include/linux/fs.h"
>extern int register_blkdev(unsigned int, const char *);
>extern void 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 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 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 *);
># 1661 "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 void unregister_chrdev(unsigned int, const char *);
>extern void unregister_chrdev_region(dev_t, unsigned);
>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 *);
># 1707 "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,
>     bool be_atomic);
>unsigned long invalidate_mapping_pages(struct address_space *mapping,
>     unsigned long start, unsigned long end);
>
>static inline __attribute__((always_inline)) unsigned long __attribute__((deprecated))
>invalidate_inode_pages(struct address_space *mapping)
>{
> return invalidate_mapping_pages(mapping, 0, ~0UL);
>}
>
>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_mapping_pages(inode->i_mapping, 0, -1);
>}
>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_path.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 struct file *do_filp_open(int dfd, const char *pathname,
>  int open_flag, int mode);
>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);
>}
># 44 "include/linux/err.h"
>static inline __attribute__((always_inline)) void *ERR_CAST(const void *ptr)
>{
>
> return (void *) ptr;
>}
># 1789 "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 *);
>
>extern void __iget(struct inode * inode);
>extern void iget_failed(struct inode *);
>extern void clear_inode(struct inode *);
>extern void destroy_inode(struct inode *);
>extern struct inode *new_inode(struct super_block *);
>extern int should_remove_suid(struct dentry *);
>extern int remove_suid(struct dentry *);
>
>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 sb_has_dirty_inodes(struct super_block *);
>
>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);
>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 int generic_segment_checks(const struct iovec *iov,
>  unsigned long *nr_segs, size_t *count, int access_flags);
>
>
>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);
># 1886 "include/linux/fs.h"
>static inline __attribute__((always_inline)) int xip_truncate_page(struct address_space *mapping, loff_t from)
>{
> return 0;
>}
>
>
>
>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 const 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 do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
>      unsigned long arg);
>
>extern void get_filesystem(struct file_system_type *fs);
>extern void put_filesystem(struct file_system_type *fs);
>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_write_begin(struct file *file, struct address_space *mapping,
>   loff_t pos, unsigned len, unsigned flags,
>   struct page **pagep, void **fsdata);
>extern int simple_write_end(struct file *file, struct address_space *mapping,
>   loff_t pos, unsigned len, unsigned copied,
>   struct page *page, void *fsdata);
>
>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 const 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);
># 2012 "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);
>
>extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
>extern void save_mount_options(struct super_block *sb, char *options);
>
>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;
>}
>
>
>
>
>
>
>
>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)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/fs.h", 2053, (__func__)); panic("BUG!"); } while (0); } while(0);
>
>
>
>
>
> __asm__ __volatile__("": : :"memory");
> ar->size = n;
>}
># 2093 "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,
>       int (*get)(void *, u64 *), int (*set)(void *, u64),
>       const char *fmt);
>int simple_attr_release(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);
># 2120 "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)
>{ }
>
>
>struct ctl_table;
>int proc_nr_files(struct ctl_table *table, int write, struct file *filp,
>    void *buffer, size_t *lenp, loff_t *ppos);
>
>int get_filesystem_list(char * buf);
># 5 "include/linux/highmem.h" 2
>
>
>
>
># 1 "include/asm/cacheflush.h" 1
>
>
>
>
># 1 "include/asm/arch/cacheflush.h" 1
># 56 "include/asm/arch/cacheflush.h"
>int _set_memory_uc(unsigned long addr, int numpages);
>int _set_memory_wc(unsigned long addr, int numpages);
>int _set_memory_wb(unsigned long addr, int numpages);
>int set_memory_uc(unsigned long addr, int numpages);
>int set_memory_wc(unsigned long addr, int numpages);
>int set_memory_wb(unsigned long addr, int numpages);
>int set_memory_x(unsigned long addr, int numpages);
>int set_memory_nx(unsigned long addr, int numpages);
>int set_memory_ro(unsigned long addr, int numpages);
>int set_memory_rw(unsigned long addr, int numpages);
>int set_memory_np(unsigned long addr, int numpages);
>int set_memory_4k(unsigned long addr, int numpages);
># 89 "include/asm/arch/cacheflush.h"
>int set_pages_uc(struct page *page, int numpages);
>int set_pages_wb(struct page *page, int numpages);
>int set_pages_x(struct page *page, int numpages);
>int set_pages_nx(struct page *page, int numpages);
>int set_pages_ro(struct page *page, int numpages);
>int set_pages_rw(struct page *page, int numpages);
>
>
>void clflush_cache_range(void *addr, unsigned int size);
>
>void cpa_init(void);
># 109 "include/asm/arch/cacheflush.h"
>static inline __attribute__((always_inline)) int rodata_test(void)
>{
> return 0;
>}
># 5 "include/asm/cacheflush.h" 2
># 9 "include/linux/highmem.h" 2
>
>
>static inline __attribute__((always_inline)) void flush_anon_page(struct vm_area_struct *vma, struct page *page, unsigned long vmaddr)
>{
>}
>
>
>
>static inline __attribute__((always_inline)) void flush_kernel_dcache_page(struct page *page)
>{
>}
># 34 "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);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void *kmap_atomic(struct page *page, enum km_type idx)
>{
> pagefault_disable();
> return lowmem_page_address(page);
>}
># 66 "include/linux/highmem.h"
>static inline __attribute__((always_inline)) void clear_user_highpage(struct page *page, unsigned long vaddr)
>{
> void *addr = kmap_atomic(page, KM_USER0);
> memset((void *)(addr), 0, ((1UL) << 12));
> do { pagefault_enable(); } while (0);
>}
># 88 "include/linux/highmem.h"
>static inline __attribute__((always_inline)) struct page *
>__alloc_zeroed_user_highpage(gfp_t movableflags,
>   struct vm_area_struct *vma,
>   unsigned long vaddr)
>{
> struct page *page = alloc_pages_node((((void)(0),0)), ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u) | (( gfp_t)0x20000u) | (( gfp_t)0x02u)) | movableflags, 0);
>
>
> if (page)
>  clear_user_highpage(page, vaddr);
>
> return page;
>}
># 111 "include/linux/highmem.h"
>static inline __attribute__((always_inline)) struct page *
>alloc_zeroed_user_highpage_movable(struct vm_area_struct *vma,
>     unsigned long vaddr)
>{
> return __alloc_zeroed_user_highpage((( gfp_t)0x100000u), vma, vaddr);
>}
>
>static inline __attribute__((always_inline)) void clear_highpage(struct page *page)
>{
> void *kaddr = kmap_atomic(page, KM_USER0);
> memset((void *)(kaddr), 0, ((1UL) << 12));
> do { pagefault_enable(); } while (0);
>}
>
>static inline __attribute__((always_inline)) void zero_user_segments(struct page *page,
> unsigned start1, unsigned end1,
> unsigned start2, unsigned end2)
>{
> void *kaddr = kmap_atomic(page, KM_USER0);
>
> do { if (__builtin_expect(!!(end1 > ((1UL) << 12) || end2 > ((1UL) << 12)), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/highmem.h", 131, (__func__)); panic("BUG!"); } while (0); } while(0);
>
> if (end1 > start1)
>  memset(kaddr + start1, 0, end1 - start1);
>
> if (end2 > start2)
>  memset(kaddr + start2, 0, end2 - start2);
>
> do { pagefault_enable(); } while (0);
> do { } while (0);
>}
>
>static inline __attribute__((always_inline)) void zero_user_segment(struct page *page,
> unsigned start, unsigned end)
>{
> zero_user_segments(page, start, end, 0, 0);
>}
>
>static inline __attribute__((always_inline)) void zero_user(struct page *page,
> unsigned start, unsigned size)
>{
> zero_user_segments(page, start, start + size, 0, 0);
>}
>
>static inline __attribute__((always_inline)) void __attribute__((deprecated)) memclear_highpage_flush(struct page *page,
>   unsigned int offset, unsigned int size)
>{
> zero_user(page, offset, size);
>}
>
>
>
>static inline __attribute__((always_inline)) void copy_user_highpage(struct page *to, struct page *from,
> unsigned long vaddr, struct vm_area_struct *vma)
>{
> char *vfrom, *vto;
>
> vfrom = kmap_atomic(from, KM_USER0);
> vto = kmap_atomic(to, KM_USER1);
> memcpy((void *)(vto), (void *)(vfrom), ((1UL) << 12));
> do { pagefault_enable(); } while (0);
> do { pagefault_enable(); } while (0);
>}
>
>
>
>static inline __attribute__((always_inline)) void copy_highpage(struct page *to, struct page *from)
>{
> char *vfrom, *vto;
>
> vfrom = kmap_atomic(from, KM_USER0);
> vto = kmap_atomic(to, KM_USER1);
> memcpy((void *)(vto), (void *)(vfrom), ((1UL) << 12));
> do { pagefault_enable(); } while (0);
> do { pagefault_enable(); } while (0);
>}
># 35 "kernel/sched.c" 2
>
># 1 "include/linux/smp_lock.h" 1
># 36 "kernel/sched.c" 2
>
># 1 "include/asm/mmu_context.h" 1
># 12 "include/asm/mmu_context.h"
>extern void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm);
>extern void arch_exit_mmap(struct mm_struct *mm);
>
>
>
>
>
>
>extern void force_flush_all(void);
>
>static inline __attribute__((always_inline)) void activate_mm(struct mm_struct *old, struct mm_struct *new)
>{
># 32 "include/asm/mmu_context.h"
> if (old != new && ((current_thread_info()->task)->flags & 0x00200000))
>  __switch_mm(&new->context.id);
>
> arch_dup_mmap(old, new);
>}
>
>static inline __attribute__((always_inline)) void switch_mm(struct mm_struct *prev, struct mm_struct *next,
>        struct task_struct *tsk)
>{
> unsigned cpu = 0;
>
> if(prev != next){
>  __cpu_clear((cpu), &(prev->cpu_vm_mask));
>  __cpu_set((cpu), &(next->cpu_vm_mask));
>  if(next != &init_mm)
>   __switch_mm(&next->context.id);
> }
>}
>
>static inline __attribute__((always_inline)) void enter_lazy_tlb(struct mm_struct *mm,
>      struct task_struct *tsk)
>{
>}
>
>extern int init_new_context(struct task_struct *task, struct mm_struct *mm);
>
>extern void destroy_context(struct mm_struct *mm);
># 37 "kernel/sched.c" 2
>
># 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/hardirq.h" 1
>
>
>
>
>
>
>
># 1 "include/asm/hardirq.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/irq.h" 1
># 25 "include/linux/irq.h"
>
># 1 "include/asm/irq_regs.h" 1
>
># 1 "include/asm-generic/irq_regs.h" 1
># 21 "include/asm-generic/irq_regs.h"
>extern __typeof__(struct pt_regs *) per_cpu____irq_regs;
>
>static inline __attribute__((always_inline)) struct pt_regs *get_irq_regs(void)
>{
> return per_cpu____irq_regs;
>}
>
>static inline __attribute__((always_inline)) struct pt_regs *set_irq_regs(struct pt_regs *new_regs)
>{
> struct pt_regs *old_regs, **pp_regs = &per_cpu____irq_regs;
>
> old_regs = *pp_regs;
> *pp_regs = new_regs;
> return old_regs;
>}
># 1 "include/asm/irq_regs.h" 2
># 26 "include/linux/irq.h" 2
>
>struct irq_desc;
>typedef void (*irq_flow_handler_t)(unsigned int irq,
>         struct irq_desc *desc);
># 74 "include/linux/irq.h"
>struct proc_dir_entry;
>struct msi_desc;
># 99 "include/linux/irq.h"
>struct irq_chip {
> const char *name;
> unsigned int (*startup)(unsigned int irq);
> void (*shutdown)(unsigned int irq);
> void (*enable)(unsigned int irq);
> void (*disable)(unsigned int irq);
>
> void (*ack)(unsigned int irq);
> void (*mask)(unsigned int irq);
> void (*mask_ack)(unsigned int irq);
> void (*unmask)(unsigned int irq);
> void (*eoi)(unsigned int irq);
>
> void (*end)(unsigned int irq);
> void (*set_affinity)(unsigned int irq, cpumask_t dest);
> int (*retrigger)(unsigned int irq);
> int (*set_type)(unsigned int irq, unsigned int flow_type);
> int (*set_wake)(unsigned int irq, unsigned int on);
>
>
>
> void (*release)(unsigned int irq, void *dev_id);
>
>
>
>
>
> const char *typename;
>};
># 153 "include/linux/irq.h"
>struct irq_desc {
> irq_flow_handler_t handle_irq;
> struct irq_chip *chip;
> struct msi_desc *msi_desc;
> void *handler_data;
> void *chip_data;
> struct irqaction *action;
> unsigned int status;
>
> unsigned int depth;
> unsigned int wake_depth;
> unsigned int irq_count;
> unsigned int irqs_unhandled;
> unsigned long last_unhandled;
> spinlock_t lock;
># 176 "include/linux/irq.h"
> struct proc_dir_entry *dir;
>
> const char *name;
>} ;
>
>extern struct irq_desc irq_desc[(14 + 1)];
>
>
>
>
>
>typedef struct irq_chip hw_irq_controller;
>
>typedef struct irq_desc irq_desc_t;
>
>
>
>
>
># 1 "include/asm/hw_irq.h" 1
># 195 "include/linux/irq.h" 2
>
>extern int setup_irq(unsigned int irq, struct irqaction *new);
># 242 "include/linux/irq.h"
>static inline __attribute__((always_inline)) void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
>{
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int select_smp_affinity(unsigned int irq)
>{
> return 1;
>}
>
>
>extern int no_irq_affinity;
>
>static inline __attribute__((always_inline)) int irq_balancing_disabled(unsigned int irq)
>{
> return irq_desc[irq].status & 0x00400000;
>}
>
>
>extern int handle_IRQ_event(unsigned int irq, struct irqaction *action);
>
>
>
>
>
>extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
>extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
>extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
>extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
>extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
>extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
>
>
>
>
>
>extern unsigned int __do_IRQ(unsigned int irq);
># 290 "include/linux/irq.h"
>static inline __attribute__((always_inline)) void generic_handle_irq(unsigned int irq)
>{
> struct irq_desc *desc = irq_desc + irq;
>
>
>
>
> if (__builtin_expect(!!(desc->handle_irq), 1))
>  desc->handle_irq(irq, desc);
> else
>  __do_IRQ(irq);
>
>}
>
>
>extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
>      int action_ret);
>
>
>void check_irq_resend(struct irq_desc *desc, unsigned int irq);
>
>
>extern int noirqdebug_setup(char *str);
>
>
>extern int can_request_irq(unsigned int irq, unsigned long irqflags);
>
>
>extern struct irq_chip no_irq_chip;
>extern struct irq_chip dummy_irq_chip;
>
>extern void
>set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
>    irq_flow_handler_t handle);
>extern void
>set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
>         irq_flow_handler_t handle, const char *name);
>
>extern void
>__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
>    const char *name);
>
>
>static inline __attribute__((always_inline)) void __set_irq_handler_unlocked(int irq,
>           irq_flow_handler_t handler)
>{
> irq_desc[irq].handle_irq = handler;
>}
>
>
>
>
>static inline __attribute__((always_inline)) void
>set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
>{
> __set_irq_handler(irq, handle, 0, ((void *)0));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>set_irq_chained_handler(unsigned int irq,
>   irq_flow_handler_t handle)
>{
> __set_irq_handler(irq, handle, 1, ((void *)0));
>}
>
>extern void set_irq_noprobe(unsigned int irq);
>extern void set_irq_probe(unsigned int irq);
>
>
>extern int create_irq(void);
>extern void destroy_irq(unsigned int irq);
>
>
>static inline __attribute__((always_inline)) int irq_has_action(unsigned int irq)
>{
> struct irq_desc *desc = irq_desc + irq;
> return desc->action != ((void *)0);
>}
>
>
>extern void dynamic_irq_init(unsigned int irq);
>extern void dynamic_irq_cleanup(unsigned int irq);
>
>
>extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
>extern int set_irq_data(unsigned int irq, void *data);
>extern int set_irq_chip_data(unsigned int irq, void *data);
>extern int set_irq_type(unsigned int irq, unsigned int type);
>extern int set_irq_msi(unsigned int irq, struct msi_desc *entry);
># 8 "include/asm/hardirq.h" 2
>
>
>
>typedef struct {
> unsigned int __softirq_pending;
>} irq_cpustat_t;
>
>
># 1 "include/linux/irq_cpustat.h" 1
># 20 "include/linux/irq_cpustat.h"
>extern irq_cpustat_t irq_stat[];
># 16 "include/asm/hardirq.h" 2
>
>
>
>static inline __attribute__((always_inline)) void ack_bad_irq(unsigned int irq)
>{
> printk("<3>" "unexpected IRQ %02x\n", irq);
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/hardirq.h", 22, (__func__)); panic("BUG!"); } while (0);
>}
># 8 "include/linux/hardirq.h" 2
># 113 "include/linux/hardirq.h"
>struct task_struct;
>
>
>static inline __attribute__((always_inline)) void account_system_vtime(struct task_struct *tsk)
>{
>}
># 146 "include/linux/hardirq.h"
>extern void irq_enter(void);
># 162 "include/linux/hardirq.h"
>extern void irq_exit(void);
># 12 "include/linux/interrupt.h" 2
># 58 "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 __attribute__((warn_unused_result)) request_irq(unsigned int, irq_handler_t handler,
>         unsigned long, const char *, void *);
>extern void free_irq(unsigned int, void *);
>
>struct device;
>
>extern int __attribute__((warn_unused_result)) devm_request_irq(struct device *dev, unsigned int irq,
>       irq_handler_t handler, unsigned long irqflags,
>       const char *devname, void *dev_id);
>extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
># 101 "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);
># 112 "include/linux/interrupt.h"
>static inline __attribute__((always_inline)) int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
>{
> return -22;
>}
>
>static inline __attribute__((always_inline)) int irq_can_set_affinity(unsigned int irq)
>{
> return 0;
>}
># 136 "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);
>}
># 225 "include/linux/interrupt.h"
>static inline __attribute__((always_inline)) void __attribute__((deprecated)) cli(void)
>{
> block_signals();
>}
>static inline __attribute__((always_inline)) void __attribute__((deprecated)) sti(void)
>{
> unblock_signals();
>}
>static inline __attribute__((always_inline)) void __attribute__((deprecated)) save_flags(unsigned long *x)
>{
> do { ({ unsigned long __dummy; typeof(*x) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (*x) = get_signals(); } while(0);
>}
>
>static inline __attribute__((always_inline)) void __attribute__((deprecated)) restore_flags(unsigned long x)
>{
> do { ({ unsigned long __dummy; typeof(x) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(x); } while(0);
>}
>
>static inline __attribute__((always_inline)) void __attribute__((deprecated)) save_and_cli(unsigned long *x)
>{
> do { do { ({ unsigned long __dummy; typeof(*x) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (*x) = get_signals(); } while(0); block_signals(); } while(0);
>}
># 266 "include/linux/interrupt.h"
>enum
>{
> HI_SOFTIRQ=0,
> TIMER_SOFTIRQ,
> NET_TX_SOFTIRQ,
> NET_RX_SOFTIRQ,
> BLOCK_SOFTIRQ,
> TASKLET_SOFTIRQ,
> SCHED_SOFTIRQ,
>
> HRTIMER_SOFTIRQ,
>
> RCU_SOFTIRQ,
>};
>
>
>
>
>
>struct softirq_action
>{
> void (*action)(struct softirq_action *);
> void *data;
>};
>
> void do_softirq(void);
> 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);
># 320 "include/linux/interrupt.h"
>struct tasklet_struct
>{
> struct tasklet_struct *next;
> unsigned long state;
> atomic_t count;
> void (*func)(unsigned long);
> unsigned long data;
>};
># 336 "include/linux/interrupt.h"
>enum
>{
> TASKLET_STATE_SCHED,
> TASKLET_STATE_RUN
>};
># 364 "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);
># 440 "include/linux/interrupt.h"
>static inline __attribute__((always_inline)) unsigned long probe_irq_on(void)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int probe_irq_off(unsigned long val)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) unsigned int probe_irq_mask(unsigned long val)
>{
> return 0;
>}
># 460 "include/linux/interrupt.h"
>extern void init_irq_proc(void);
>
>
>
>
>
>
>int show_interrupts(struct seq_file *p, void *v);
># 38 "kernel/sched.c" 2
>
>
>
># 1 "include/linux/kernel_stat.h" 1
># 17 "include/linux/kernel_stat.h"
>struct cpu_usage_stat {
> cputime64_t user;
> cputime64_t nice;
> cputime64_t system;
> cputime64_t softirq;
> cputime64_t irq;
> cputime64_t idle;
> cputime64_t iowait;
> cputime64_t steal;
> cputime64_t guest;
>};
>
>struct kernel_stat {
> struct cpu_usage_stat cpustat;
> unsigned int irqs[(14 + 1)];
>};
>
>extern __typeof__(struct kernel_stat) per_cpu__kstat;
>
>
>
>
>
>extern unsigned long long nr_context_switches(void);
>
>
>
>
>static inline __attribute__((always_inline)) int kstat_irqs(int irq)
>{
> int cpu, sum = 0;
>
> for (((cpu)) = 0; ((cpu)) < 1; ((cpu))++, (void)cpu_possible_map)
>  sum += (*((void)(cpu), &per_cpu__kstat)).irqs[irq];
>
> return sum;
>}
>
>extern void account_user_time(struct task_struct *, cputime_t);
>extern void account_user_time_scaled(struct task_struct *, cputime_t);
>extern void account_system_time(struct task_struct *, int, cputime_t);
>extern void account_system_time_scaled(struct task_struct *, cputime_t);
>extern void account_steal_time(struct task_struct *, cputime_t);
># 41 "kernel/sched.c" 2
>
>
># 1 "include/linux/security.h" 1
># 26 "include/linux/security.h"
>
># 1 "include/linux/binfmts.h" 1
>
>
>
>
>
>struct pt_regs;
># 27 "include/linux/binfmts.h"
>struct linux_binprm{
> char buf[128];
>
> struct vm_area_struct *vma;
>
>
>
>
> struct mm_struct *mm;
> unsigned long p;
> unsigned int sh_bang:1,
>       misc_bang:1;
> struct file * file;
> int e_uid, e_gid;
> kernel_cap_t cap_inheritable, cap_permitted;
> bool cap_effective;
> void *security;
> int argc, envc;
> char * filename;
> char * interp;
>
>
> unsigned interp_flags;
> unsigned interp_data;
> unsigned long loader, exec;
>};
># 66 "include/linux/binfmts.h"
>struct linux_binfmt {
> struct list_head lh;
> 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 limit);
> unsigned long min_coredump;
> int hasvdso;
>};
>
>extern int register_binfmt(struct linux_binfmt *);
>extern void unregister_binfmt(struct linux_binfmt *);
>
>extern int prepare_binprm(struct linux_binprm *);
>extern int __attribute__((warn_unused_result)) 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;
># 94 "include/linux/binfmts.h"
>extern int setup_arg_pages(struct linux_binprm * bprm,
>      unsigned long stack_top,
>      int executable_stack);
>extern int bprm_mm_init(struct linux_binprm *bprm);
>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);
>extern void free_bprm(struct linux_binprm *);
># 27 "include/linux/security.h" 2
>
>
>
>
># 1 "include/linux/shm.h" 1
># 28 "include/linux/shm.h"
>
># 1 "include/asm/shmparam.h" 1
>
>
>
>
># 1 "include/asm/arch/shmparam.h" 1
># 5 "include/asm/shmparam.h" 2
># 29 "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
>
>
>
>
># 1 "include/asm/arch/shmbuf.h" 1
># 17 "include/asm/arch/shmbuf.h"
>struct shmid64_ds {
> struct ipc64_perm shm_perm;
> size_t shm_segsz;
> __kernel_time_t shm_atime;
>
>
>
> __kernel_time_t shm_dtime;
>
>
>
> __kernel_time_t shm_ctime;
>
>
>
> __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;
>};
># 5 "include/asm/shmbuf.h" 2
># 48 "include/linux/shm.h" 2
># 68 "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;
> 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;
>};
># 107 "include/linux/shm.h"
>long do_shmat(int shmid, char *shmaddr, int shmflg, unsigned long *addr);
>extern int is_file_shm_hugepages(struct file *file);
># 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
>
>
>
>
># 1 "include/asm/arch/msgbuf.h" 1
># 16 "include/asm/arch/msgbuf.h"
>struct msqid64_ds {
> struct ipc64_perm msg_perm;
> __kernel_time_t msg_stime;
>
>
>
> __kernel_time_t msg_rtime;
>
>
>
> __kernel_time_t msg_ctime;
>
>
>
> 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;
>};
># 5 "include/asm/msgbuf.h" 2
># 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;
>};
># 78 "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;
> 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;
>};
>
>
>extern long do_msgsnd(int msqid, long mtype, void *mtext,
>   size_t msgsz, int msgflg);
>extern long do_msgrcv(int msqid, long *pmtype, void *mtext,
>   size_t msgsz, long msgtyp, int msgflg);
># 32 "include/linux/security.h" 2
>
>
># 1 "include/linux/key.h" 1
># 22 "include/linux/key.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];
>};
># 60 "include/linux/sysctl.h"
>enum
>{
> CTL_KERN=1,
> CTL_VM=2,
> CTL_NET=3,
> CTL_PROC=4,
> CTL_FS=5,
> CTL_DEBUG=6,
> CTL_DEV=7,
> CTL_BUS=8,
> CTL_ABI=9,
> CTL_CPU=10,
> CTL_ARLAN=254,
> CTL_S390DBF=5677,
> CTL_SUNRPC=7249,
> CTL_PM=9899,
> CTL_FRV=9898,
>};
>
>
>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_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,
> NET_IRDA=412,
>};
>
>
>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,
> NET_CORE_WARNINGS=22,
>};
>
>
>
>
>
>
>
>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,
> NET_TCP_AVAIL_CONG_CONTROL=122,
> NET_TCP_ALLOWED_CONG_CONTROL=123,
> NET_TCP_MAX_SSTHRESH=124,
> NET_TCP_FRTO_RESPONSE=125,
>};
>
>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_ACCEPT_SOURCE_ROUTE=25,
> __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_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,
> NET_X25_FORWARD=6
>};
>
>
>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,
> NET_BRIDGE_NF_FILTER_PPPOE_TAGGED = 5,
>};
>
>
>enum {
> NET_IRDA_DISCOVERY=1,
> NET_IRDA_DEVNAME=2,
> NET_IRDA_DEBUG=3,
> NET_IRDA_FAST_POLL=4,
> NET_IRDA_DISCOVERY_SLOTS=5,
> NET_IRDA_DISCOVERY_TIMEOUT=6,
> NET_IRDA_SLOT_TIMEOUT=7,
> NET_IRDA_MAX_BAUD_RATE=8,
> NET_IRDA_MIN_TX_TURN_TIME=9,
> NET_IRDA_MAX_TX_DATA_SIZE=10,
> NET_IRDA_MAX_TX_WINDOW=11,
> NET_IRDA_MAX_NOREPLY_TIME=12,
> NET_IRDA_WARN_NOREPLY_TIME=13,
> NET_IRDA_LAP_KEEPALIVE_TIME=14,
>};
>
>
>
>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,
> FS_OCFS2=988,
>};
>
>
>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,
>};
>
>
>
>
>
>struct ctl_table;
>struct nsproxy;
>struct ctl_table_root;
>
>extern struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev);
>extern struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
>      struct ctl_table_header *prev);
>extern void sysctl_head_finish(struct ctl_table_header *prev);
>extern int sysctl_perm(struct ctl_table_root *root,
>  struct ctl_table *table, int op);
>
>typedef struct ctl_table ctl_table;
>
>typedef int ctl_handler (struct ctl_table *table, int *name, int nlen,
>    void *oldval, size_t *oldlenp,
>    void *newval, size_t newlen);
>
>typedef int proc_handler (struct ctl_table *ctl, int write, struct file * filp,
>     void *buffer, size_t *lenp, loff_t *ppos);
>
>extern int proc_dostring(struct ctl_table *, int, struct file *,
>    void *, size_t *, loff_t *);
>extern int proc_dointvec(struct ctl_table *, int, struct file *,
>    void *, size_t *, loff_t *);
>extern int proc_dointvec_minmax(struct ctl_table *, int, struct file *,
>    void *, size_t *, loff_t *);
>extern int proc_dointvec_jiffies(struct ctl_table *, int, struct file *,
>     void *, size_t *, loff_t *);
>extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int, struct file *,
>     void *, size_t *, loff_t *);
>extern int proc_dointvec_ms_jiffies(struct ctl_table *, int, struct file *,
>        void *, size_t *, loff_t *);
>extern int proc_doulongvec_minmax(struct ctl_table *, int, struct file *,
>      void *, size_t *, loff_t *);
>extern int proc_doulongvec_ms_jiffies_minmax(struct 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 ctl_handler sysctl_data;
>extern ctl_handler sysctl_string;
>extern ctl_handler sysctl_intvec;
>extern ctl_handler sysctl_jiffies;
>extern ctl_handler sysctl_ms_jiffies;
># 1035 "include/linux/sysctl.h"
>struct ctl_table
>{
> int ctl_name;
> const char *procname;
> void *data;
> int maxlen;
> mode_t mode;
> struct ctl_table *child;
> struct ctl_table *parent;
> proc_handler *proc_handler;
> ctl_handler *strategy;
> void *extra1;
> void *extra2;
>};
>
>struct ctl_table_root {
> struct list_head root_list;
> struct list_head header_list;
> struct list_head *(*lookup)(struct ctl_table_root *root,
>        struct nsproxy *namespaces);
> int (*permissions)(struct ctl_table_root *root,
>   struct nsproxy *namespaces, struct ctl_table *table);
>};
>
>
>
>struct ctl_table_header
>{
> struct ctl_table *ctl_table;
> struct list_head ctl_entry;
> int used;
> struct completion *unregistering;
> struct ctl_table *ctl_table_arg;
> struct ctl_table_root *root;
>};
>
>
>struct ctl_path {
> const char *procname;
> int ctl_name;
>};
>
>void register_sysctl_root(struct ctl_table_root *root);
>struct ctl_table_header *__register_sysctl_paths(
> struct ctl_table_root *root, struct nsproxy *namespaces,
> const struct ctl_path *path, struct ctl_table *table);
>struct ctl_table_header *register_sysctl_table(struct ctl_table * table);
>struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
>      struct ctl_table *table);
>
>void unregister_sysctl_table(struct ctl_table_header * table);
>int sysctl_check_table(struct nsproxy *namespaces, struct ctl_table *table);
># 23 "include/linux/key.h" 2
>
>
>
>
>
>typedef int32_t key_serial_t;
>
>
>typedef uint32_t key_perm_t;
>
>struct key;
># 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];
> unsigned int alg_key_len;
> char alg_key[0];
>};
>
>struct xfrm_algo_aead {
> char alg_name[64];
> unsigned int alg_key_len;
> unsigned int alg_icv_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,
> XFRM_POLICY_TYPE_ANY = 255
>};
>
>enum
>{
> XFRM_POLICY_IN = 0,
> XFRM_POLICY_OUT = 1,
> XFRM_POLICY_FWD = 2,
> XFRM_POLICY_MASK = 3,
> XFRM_POLICY_MAX = 3
>};
>
>enum
>{
> XFRM_SHARE_ANY,
> XFRM_SHARE_SESSION,
> XFRM_SHARE_USER,
> XFRM_SHARE_UNIQUE
>};
># 145 "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_MIGRATE,
>
>
> XFRM_MSG_NEWSADINFO,
>
> XFRM_MSG_GETSADINFO,
>
>
> XFRM_MSG_NEWSPDINFO,
>
> XFRM_MSG_GETSPDINFO,
>
> __XFRM_MSG_MAX
>};
># 212 "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;
> __be16 encap_sport;
> __be16 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_MIGRATE,
> XFRMA_ALG_AEAD,
> __XFRMA_MAX
>
>
>};
>
>enum xfrm_sadattr_type_t {
> XFRMA_SAD_UNSPEC,
> XFRMA_SAD_CNT,
> XFRMA_SAD_HINFO,
> __XFRMA_SAD_MAX
>
>
>};
>
>struct xfrmu_sadhinfo {
> __u32 sadhcnt;
> __u32 sadhmcnt;
>};
>
>enum xfrm_spdattr_type_t {
> XFRMA_SPD_UNSPEC,
> XFRMA_SPD_INFO,
> XFRMA_SPD_HINFO,
> __XFRMA_SPD_MAX
>
>
>};
>
>struct xfrmu_spdinfo {
> __u32 incnt;
> __u32 outcnt;
> __u32 fwdcnt;
> __u32 inscnt;
> __u32 outscnt;
> __u32 fwdscnt;
>};
>
>struct xfrmu_spdhinfo {
> __u32 spdhcnt;
> __u32 spdhmcnt;
>};
>
>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;
> xfrm_address_t saddr;
> __u32 flags;
> __u32 reqid;
>};
>
>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;
>};
>
>struct xfrm_user_migrate {
> xfrm_address_t old_daddr;
> xfrm_address_t old_saddr;
> xfrm_address_t new_daddr;
> xfrm_address_t new_saddr;
> __u8 proto;
> __u8 mode;
> __u16 reserved;
> __u32 reqid;
> __u16 old_family;
> __u16 new_family;
>};
># 439 "include/linux/xfrm.h"
>enum xfrm_nlgroups {
> XFRMNLGRP_NONE,
>
> XFRMNLGRP_ACQUIRE,
>
> XFRMNLGRP_EXPIRE,
>
> XFRMNLGRP_SA,
>
> XFRMNLGRP_POLICY,
>
> XFRMNLGRP_AEVENTS,
>
> XFRMNLGRP_REPORT,
>
> XFRMNLGRP_MIGRATE,
>
> __XFRMNLGRP_MAX
>};
># 35 "include/linux/security.h" 2
>
># 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;
>
>
>
>};
>
>
>
>
>
>extern const struct in6_addr kernel_in6addr_any;
>
>extern const struct in6_addr kernel_in6addr_loopback;
>
>
>extern const struct in6_addr in6addr_linklocal_allnodes;
>
>
>extern const struct in6_addr in6addr_linklocal_allrouters;
>
>
>
>
>struct sockaddr_in6 {
> unsigned short int sin6_family;
> __be16 sin6_port;
> __be32 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;
> __be32 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;
> __u32 mark;
>
> union {
>  struct {
>   __be32 daddr;
>   __be32 saddr;
>   __u8 tos;
>   __u8 scope;
>  } ip4_u;
>
>  struct {
>   struct in6_addr daddr;
>   struct in6_addr saddr;
>   __be32 flowlabel;
>  } ip6_u;
>
>  struct {
>   __le16 daddr;
>   __le16 saddr;
>   __u8 scope;
>  } dn_u;
> } nl_u;
># 49 "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;
>
>  struct {
>   __u8 type;
>  } mht;
> } uli_u;
>
>
>
>
>
>
> __u32 secid;
>} __attribute__((__aligned__(64/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;
>
>static inline __attribute__((always_inline)) int flow_cache_uli_match(struct flowi *fl1, struct flowi *fl2)
>{
> return (fl1->proto == fl2->proto &&
>  !memcmp(&fl1->uli_u, &fl2->uli_u, sizeof(fl1->uli_u)));
>}
># 36 "include/linux/security.h" 2
>
>
>
>
>struct ctl_table;
>struct audit_krule;
>
>
>
>
>
>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, const char *name,
>         const void *value, size_t size, int flags);
>extern int cap_inode_removexattr(struct dentry *dentry, const char *name);
>extern int cap_inode_need_killpriv(struct dentry *dentry);
>extern int cap_inode_killpriv(struct dentry *dentry);
>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_task_prctl(int option, unsigned long arg2, unsigned long arg3,
>     unsigned long arg4, unsigned long arg5, long *rc_p);
>extern int cap_task_setscheduler(struct task_struct *p, int policy, struct sched_param *lp);
>extern int cap_task_setioprio(struct task_struct *p, int ioprio);
>extern int cap_task_setnice(struct task_struct *p, int nice);
>extern int cap_syslog(int type);
>extern int cap_vm_enough_memory(struct mm_struct *mm, 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);
>
>extern unsigned long mmap_min_addr;
># 103 "include/linux/security.h"
>struct nfsctl_arg;
>struct sched_param;
>struct swap_info_struct;
>struct request_sock;
># 1737 "include/linux/security.h"
>struct security_mnt_opts {
>};
>
>static inline __attribute__((always_inline)) void security_init_mnt_opts(struct security_mnt_opts *opts)
>{
>}
>
>static inline __attribute__((always_inline)) void security_free_mnt_opts(struct security_mnt_opts *opts)
>{
>}
>
>
>
>
>
>
>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((current_thread_info()->task)->mm, pages);
>}
>
>static inline __attribute__((always_inline)) int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
>{
> return cap_vm_enough_memory(mm, 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(char *orig, char *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 path *path,
>        char *type, unsigned long flags,
>        void *data)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int security_sb_check_sb(struct vfsmount *mnt,
>           struct path *path)
>{
> 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_addmount(struct vfsmount *mnt,
>          struct path *mountpoint)
>{ }
>
>static inline __attribute__((always_inline)) int security_sb_pivotroot(struct path *old_path,
>     struct path *new_path)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void security_sb_post_pivotroot(struct path *old_path,
>           struct path *new_path)
>{ }
>static inline __attribute__((always_inline)) int security_sb_get_mnt_opts(const struct super_block *sb,
>        struct security_mnt_opts *opts)
>{
> security_init_mnt_opts(opts);
> return 0;
>}
>
>static inline __attribute__((always_inline)) int security_sb_set_mnt_opts(struct super_block *sb,
>        struct security_mnt_opts *opts)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void security_sb_clone_mnt_opts(const struct super_block *oldsb,
>           struct super_block *newsb)
>{ }
>
>static inline __attribute__((always_inline)) int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts)
>{
> return 0;
>}
>
>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,
>  const char *name, const 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,
>  const char *name, const void *value, size_t size, int flags)
>{ }
>
>static inline __attribute__((always_inline)) int security_inode_getxattr(struct dentry *dentry,
>   const 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,
>   const char *name)
>{
> return cap_inode_removexattr(dentry, name);
>}
>
>static inline __attribute__((always_inline)) int security_inode_need_killpriv(struct dentry *dentry)
>{
> return cap_inode_need_killpriv(dentry);
>}
>
>static inline __attribute__((always_inline)) int security_inode_killpriv(struct dentry *dentry)
>{
> return cap_inode_killpriv(dentry);
>}
>
>static inline __attribute__((always_inline)) int security_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
>{
> 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)) void security_inode_getsecid(const struct inode *inode, u32 *secid)
>{
> *secid = 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,
>         unsigned long addr,
>         unsigned long addr_only)
>{
> 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_dentry_open(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)
>{
> *secid = 0;
>}
>
>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 cap_task_setnice(p, nice);
>}
>
>static inline __attribute__((always_inline)) int security_task_setioprio(struct task_struct *p, int ioprio)
>{
> return cap_task_setioprio(p, ioprio);
>}
>
>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 cap_task_setscheduler(p, policy, lp);
>}
>
>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, long *rc_p)
>{
> return cap_task_prctl(option, arg2, arg3, arg3, arg5, rc_p);
>}
>
>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)) void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
>{
> *secid = 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, char **value)
>{
> 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,
>      const 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)) int security_secctx_to_secid(const char *secdata,
>        u32 seclen,
>        u32 *secid)
>{
> return -95;
>}
>
>static inline __attribute__((always_inline)) void security_release_secctx(char *secdata, u32 seclen)
>{
>}
># 2503 "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)
>{
>}
>
>static inline __attribute__((always_inline)) void security_inet_conn_established(struct sock *sk,
>   struct sk_buff *skb)
>{
>}
># 2677 "include/linux/security.h"
>static inline __attribute__((always_inline)) int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp, struct xfrm_user_sec_ctx *sec_ctx)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int security_xfrm_policy_clone(struct xfrm_sec_ctx *old, struct xfrm_sec_ctx **new_ctxp)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
>{
>}
>
>static inline __attribute__((always_inline)) int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
>{
> 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_sec_ctx *ctx, 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_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)
>{
>}
># 43 "kernel/sched.c" 2
>
>
># 1 "include/linux/profile.h" 1
># 11 "include/linux/profile.h"
>extern int prof_on ;
>
>
>
>
>
>
>struct proc_dir_entry;
>struct pt_regs;
>struct notifier_block;
>
>
>void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) profile_init(void);
>void profile_tick(int);
>
>
>
>
>void profile_hits(int, void *ip, unsigned int nr_hits);
>
>
>
>
>static inline __attribute__((always_inline)) void profile_hit(int type, void *ip)
>{
>
>
>
> if (__builtin_expect(!!(prof_on == type), 0))
>  profile_hits(type, ip, 1);
>}
>
>
>void create_prof_cpu_mask(struct proc_dir_entry *);
>
>
>
>
>enum profile_type {
> PROFILE_TASK_EXIT,
> PROFILE_MUNMAP
>};
># 83 "include/linux/profile.h"
>static inline __attribute__((always_inline)) int task_handoff_register(struct notifier_block * n)
>{
> return -38;
>}
>
>static inline __attribute__((always_inline)) int task_handoff_unregister(struct notifier_block * n)
>{
> return -38;
>}
>
>static inline __attribute__((always_inline)) int profile_event_register(enum profile_type t, struct notifier_block * n)
>{
> return -38;
>}
>
>static inline __attribute__((always_inline)) int profile_event_unregister(enum profile_type t, struct notifier_block * n)
>{
> return -38;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int register_timer_hook(int (*hook)(struct pt_regs *))
>{
> return -38;
>}
>
>static inline __attribute__((always_inline)) void unregister_timer_hook(int (*hook)(struct pt_regs *))
>{
> return;
>}
># 45 "kernel/sched.c" 2
>
># 1 "include/linux/freezer.h" 1
># 161 "include/linux/freezer.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 set_freeze_flag(struct task_struct *p) {}
>static inline __attribute__((always_inline)) void clear_freeze_flag(struct task_struct *p) {}
>static inline __attribute__((always_inline)) int thaw_process(struct task_struct *p) { return 1; }
>
>static inline __attribute__((always_inline)) void refrigerator(void) {}
>static inline __attribute__((always_inline)) int freeze_processes(void) { do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/freezer.h", 168, (__func__)); 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; }
>
>static inline __attribute__((always_inline)) void freezer_do_not_count(void) {}
>static inline __attribute__((always_inline)) void freezer_count(void) {}
>static inline __attribute__((always_inline)) int freezer_should_skip(struct task_struct *p) { return 0; }
>static inline __attribute__((always_inline)) void set_freezable(void) {}
># 46 "kernel/sched.c" 2
>
># 1 "include/linux/vmalloc.h" 1
>
>
>
>
>
>
>struct vm_area_struct;
># 25 "include/linux/vmalloc.h"
>struct vm_struct {
>
> struct vm_struct *next;
> void *addr;
> unsigned long size;
> unsigned long flags;
> struct page **pages;
> unsigned int nr_pages;
> unsigned long phys_addr;
> void *caller;
>};
>
>
>
>
>extern void *vmalloc(unsigned long size);
>extern void *vmalloc_user(unsigned long size);
>extern void *vmalloc_node(unsigned long size, int node);
>extern void *vmalloc_exec(unsigned long size);
>extern void *vmalloc_32(unsigned long size);
>extern void *vmalloc_32_user(unsigned long size);
>extern void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot);
>extern void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask,
>    pgprot_t prot);
>extern void vfree(const void *addr);
>
>extern void *kernel_vmap(struct page **pages, unsigned int count,
>   unsigned long flags, pgprot_t prot);
>extern void vunmap(const void *addr);
>
>extern int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
>       unsigned long pgoff);
>void vmalloc_sync_all(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) size_t get_vm_area_size(const struct vm_struct *area)
>{
>
> return area->size - ((1UL) << 12);
>}
>
>extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
>extern struct vm_struct *get_vm_area_caller(unsigned long size,
>     unsigned long flags, void *caller);
>extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
>     unsigned long start, unsigned long end);
>extern struct vm_struct *get_vm_area_node(unsigned long size,
>       unsigned long flags, int node,
>       gfp_t gfp_mask);
>extern struct vm_struct *remove_vm_area(const void *addr);
>
>extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
>   struct page ***pages);
>extern void unmap_kernel_range(unsigned long addr, unsigned long size);
>
>
>extern struct vm_struct *alloc_vm_area(size_t size);
>extern void free_vm_area(struct vm_struct *area);
>
>
>
>
>extern rwlock_t vmlist_lock;
>extern struct vm_struct *vmlist;
>
>extern const struct seq_operations vmalloc_op;
># 47 "kernel/sched.c" 2
>
># 1 "include/linux/blkdev.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/major.h" 1
># 8 "include/linux/blkdev.h" 2
>
># 1 "include/linux/genhd.h" 1
># 21 "include/linux/genhd.h"
>extern struct device_type part_type;
>extern struct kobject *block_depr;
>extern struct class block_class;
>
>extern const struct seq_operations partitions_op;
>extern const struct seq_operations diskstats_op;
>
>enum {
>
>
> DOS_EXTENDED_PARTITION = 5,
> LINUX_EXTENDED_PARTITION = 0x85,
> WIN98_EXTENDED_PARTITION = 0x0f,
>
> SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
>
> LINUX_SWAP_PARTITION = 0x82,
> LINUX_DATA_PARTITION = 0x83,
> LINUX_LVM_PARTITION = 0x8e,
> LINUX_RAID_PARTITION = 0xfd,
>
> SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
> NEW_SOLARIS_X86_PARTITION = 0xbf,
>
> DM6_AUX1PARTITION = 0x51,
> DM6_AUX3PARTITION = 0x53,
> DM6_PARTITION = 0x54,
> EZD_PARTITION = 0x55,
>
> FREEBSD_PARTITION = 0xa5,
> OPENBSD_PARTITION = 0xa6,
> NETBSD_PARTITION = 0xa9,
> BSDI_PARTITION = 0xb7,
> MINIX_PARTITION = 0x81,
> UNIXWARE_PARTITION = 0x63,
>};
>
>
>
># 1 "include/linux/device.h" 1
># 15 "include/linux/device.h"
>
># 1 "include/linux/ioport.h" 1
># 18 "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;
>};
># 101 "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 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);
>resource_size_t resource_alignment(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);
>}
>
>
>struct device;
>
>
>
>
>
>extern struct resource * __devm_request_region(struct device *dev,
>    struct resource *parent, resource_size_t start,
>    resource_size_t n, const char *name);
>
>
>
>
>
>
>extern void __devm_release_region(struct device *dev, struct resource *parent,
>      resource_size_t start, resource_size_t n);
># 16 "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 *);
>};
># 37 "include/linux/klist.h"
>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_add_after(struct klist_node *n, struct klist_node *pos);
>extern void klist_add_before(struct klist_node *n, struct klist_node *pos);
>
>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);
># 18 "include/linux/device.h" 2
>
>
>
>
>
># 1 "include/linux/pm.h" 1
># 33 "include/linux/pm.h"
>typedef int pm_request_t;
># 42 "include/linux/pm.h"
>typedef int pm_dev_t;
># 55 "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,
>};
># 74 "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);
>extern void (*pm_power_off_prepare)(void);
>
>
>
>
>
>struct device;
>
>typedef struct pm_message {
> int event;
>} pm_message_t;
># 181 "include/linux/pm.h"
>struct dev_pm_info {
> pm_message_t power_state;
> unsigned can_wakeup:1;
> unsigned should_wakeup:1;
> bool sleeping:1;
>
>
>
>};
>
>extern int device_power_down(pm_message_t state);
>extern void device_power_up(void);
>extern void device_resume(void);
># 208 "include/linux/pm.h"
>static inline __attribute__((always_inline)) int device_suspend(pm_message_t state)
>{
> return 0;
>}
># 221 "include/linux/pm.h"
>extern unsigned int pm_flags;
># 23 "include/linux/device.h" 2
>
>
>
># 1 "include/asm/device.h" 1
>
>
>
>
>
>
># 1 "include/asm-generic/device.h" 1
># 9 "include/asm-generic/device.h"
>struct dev_archdata {
>};
># 7 "include/asm/device.h" 2
># 26 "include/linux/device.h" 2
># 34 "include/linux/device.h"
>struct device;
>struct device_driver;
>struct driver_private;
>struct class;
>struct bus_type;
>struct bus_type_private;
>
>struct bus_attribute {
> struct attribute attr;
> ssize_t (*show)(struct bus_type *bus, char *buf);
> ssize_t (*store)(struct bus_type *bus, 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 bus_type {
> const char *name;
> 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, struct kobj_uevent_env *env);
> 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);
>
> struct bus_type_private *p;
>};
>
>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 *dev, void *data));
>struct device *bus_find_device(struct bus_type *bus, struct device *start,
>          void *data,
>          int (*match)(struct device *dev, void *data));
>struct device *bus_find_device_by_name(struct bus_type *bus,
>           struct device *start,
>           const char *name);
>
>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 notifier_block;
>
>extern int bus_register_notifier(struct bus_type *bus,
>     struct notifier_block *nb);
>extern int bus_unregister_notifier(struct bus_type *bus,
>       struct notifier_block *nb);
># 117 "include/linux/device.h"
>extern struct kset *bus_get_kset(struct bus_type *bus);
>extern struct klist *bus_get_device_klist(struct bus_type *bus);
>
>struct device_driver {
> const char *name;
> struct bus_type *bus;
>
> struct module *owner;
> const char *mod_name;
>
> 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);
> struct attribute_group **groups;
>
> struct driver_private *p;
>};
>
>
>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 *driver, char *buf);
> ssize_t (*store)(struct device_driver *driver, const char *buf,
>    size_t count);
>};
>
>
>
>
>
>extern int __attribute__((warn_unused_result)) driver_create_file(struct device_driver *driver,
>        struct driver_attribute *attr);
>extern void driver_remove_file(struct device_driver *driver,
>          struct driver_attribute *attr);
>
>extern int __attribute__((warn_unused_result)) driver_add_kobj(struct device_driver *drv,
>     struct kobject *kobj,
>     const char *fmt, ...);
>
>extern int __attribute__((warn_unused_result)) driver_for_each_device(struct device_driver *drv,
>            struct device *start,
>            void *data,
>            int (*fn)(struct device *dev,
>        void *));
>struct device *driver_find_device(struct device_driver *drv,
>      struct device *start, void *data,
>      int (*match)(struct device *dev, void *data));
>
>
>
>
>struct class {
> const char *name;
> struct module *owner;
>
> struct kset subsys;
> struct list_head devices;
> struct list_head interfaces;
> struct kset class_dirs;
> struct semaphore sem;
> struct class_attribute *class_attrs;
> struct device_attribute *dev_attrs;
>
> int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
>
> void (*class_release)(struct class *class);
> void (*dev_release)(struct device *dev);
>
> int (*suspend)(struct device *dev, pm_message_t state);
> int (*resume)(struct device *dev);
>};
>
>extern int __attribute__((warn_unused_result)) class_register(struct class *class);
>extern void class_unregister(struct class *class);
>extern int class_for_each_device(struct class *class, void *data,
>     int (*fn)(struct device *dev, void *data));
>extern struct device *class_find_device(struct class *class, void *data,
>     int (*match)(struct device *, void *));
>
>struct class_attribute {
> struct attribute attr;
> ssize_t (*show)(struct class *class, char *buf);
> ssize_t (*store)(struct class *class, const char *buf, size_t count);
>};
>
>
>
>
>extern int __attribute__((warn_unused_result)) class_create_file(struct class *class,
>       const struct class_attribute *attr);
>extern void class_remove_file(struct class *class,
>         const struct class_attribute *attr);
>
>struct class_interface {
> struct list_head node;
> struct class *class;
>
> 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);
># 246 "include/linux/device.h"
>struct device_type {
> const char *name;
> struct attribute_group **groups;
> int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
> void (*release)(struct device *dev);
> int (*suspend)(struct device *dev, pm_message_t state);
> int (*resume)(struct device *dev);
>};
>
>
>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);
>extern int device_schedule_callback_owner(struct device *dev,
>  void (*func)(struct device *dev), struct module *owner);
>
>
>
>
>
>
>typedef void (*dr_release_t)(struct device *dev, void *res);
>typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
>
>
>
>
>
>
>
>extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
>
>extern void devres_free(void *res);
>extern void devres_add(struct device *dev, void *res);
>extern void *devres_find(struct device *dev, dr_release_t release,
>    dr_match_t match, void *match_data);
>extern void *devres_get(struct device *dev, void *new_res,
>   dr_match_t match, void *match_data);
>extern void *devres_remove(struct device *dev, dr_release_t release,
>      dr_match_t match, void *match_data);
>extern int devres_destroy(struct device *dev, dr_release_t release,
>     dr_match_t match, void *match_data);
>
>
>extern void * __attribute__((warn_unused_result)) devres_open_group(struct device *dev, void *id,
>          gfp_t gfp);
>extern void devres_close_group(struct device *dev, void *id);
>extern void devres_remove_group(struct device *dev, void *id);
>extern int devres_release_group(struct device *dev, void *id);
>
>
>extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
>extern void devm_kfree(struct device *dev, void *p);
>
>struct device_dma_parameters {
>
>
>
>
> unsigned int max_segment_size;
> unsigned long segment_boundary_mask;
>};
>
>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];
> struct device_type *type;
> unsigned uevent_suppress:1;
>
> struct semaphore sem;
>
>
>
> struct bus_type *bus;
> struct device_driver *driver;
>
> void *driver_data;
> void *platform_data;
>
> struct dev_pm_info power;
>
>
>
>
> u64 *dma_mask;
> u64 coherent_dma_mask;
>
>
>
>
>
> struct device_dma_parameters *dma_parms;
>
> struct list_head dma_pools;
>
> struct dma_coherent_mem *dma_mem;
>
>
> struct dev_archdata archdata;
>
> spinlock_t devres_lock;
> struct list_head devres_head;
>
> struct list_head node;
> struct class *class;
> dev_t devt;
> struct attribute_group **groups;
>
> void (*release)(struct device *dev);
>};
>
>
>
># 1 "include/linux/pm_wakeup.h" 1
># 70 "include/linux/pm_wakeup.h"
>static inline __attribute__((always_inline)) void device_init_wakeup(struct device *dev, int val)
>{
> dev->power.can_wakeup = !!val;
>}
>
>static inline __attribute__((always_inline)) int device_can_wakeup(struct device *dev)
>{
> return dev->power.can_wakeup;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int call_platform_enable_wakeup(struct device *dev, int is_on)
>{
> return 0;
>}
># 381 "include/linux/device.h" 2
>
>static inline __attribute__((always_inline)) const char *dev_name(struct device *dev)
>{
>
> return dev->bus_id;
>}
>
>extern int dev_set_name(struct device *dev, const char *name, ...)
>   __attribute__((format(printf, 2, 3)));
># 401 "include/linux/device.h"
>static inline __attribute__((always_inline)) int dev_to_node(struct device *dev)
>{
> return -1;
>}
>static inline __attribute__((always_inline)) void set_dev_node(struct device *dev, int node)
>{
>}
>
>
>static inline __attribute__((always_inline)) void *dev_get_drvdata(struct device *dev)
>{
> return dev->driver_data;
>}
>
>static inline __attribute__((always_inline)) void dev_set_drvdata(struct device *dev, void *data)
>{
> dev->driver_data = data;
>}
>
>static inline __attribute__((always_inline)) int device_is_registered(struct device *dev)
>{
> return dev->kobj.state_in_sysfs;
>}
>
>void driver_init(void);
>
>
>
>
>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 *dev, void *data,
>       int (*fn)(struct device *dev, void *data));
>extern struct device *device_find_child(struct device *dev, void *data,
>    int (*match)(struct device *dev, void *data));
>extern int device_rename(struct device *dev, char *new_name);
>extern int device_move(struct device *dev, struct device *new_parent);
>
>
>
>
>
>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_vargs(struct class *cls,
>       struct device *parent,
>       dev_t devt,
>       void *drvdata,
>       const char *fmt,
>       va_list vargs);
>extern struct device *device_create(struct class *cls, struct device *parent,
>        dev_t devt, const char *fmt, ...)
>        __attribute__((format(printf, 4, 5)));
>extern struct device *device_create_drvdata(struct class *cls,
>         struct device *parent,
>         dev_t devt,
>         void *drvdata,
>         const char *fmt, ...)
>        __attribute__((format(printf, 5, 6)));
>extern void device_destroy(struct class *cls, dev_t devt);
>
>
>
>
>
>
>
>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 void sysdev_shutdown(void);
>
>
>extern const char *dev_driver_string(struct device *dev);
># 60 "include/linux/genhd.h" 2
>
>
>
>
>
>struct partition {
> unsigned char boot_ind;
> unsigned char head;
> unsigned char sector;
> unsigned char cyl;
> unsigned char sys_ind;
> unsigned char end_head;
> unsigned char end_sector;
> unsigned char end_cyl;
> __le32 start_sect;
> __le32 nr_sects;
>} __attribute__((packed));
>
>struct disk_stats {
> unsigned long sectors[2];
> unsigned long ios[2];
> unsigned long merges[2];
> unsigned long ticks[2];
> unsigned long io_ticks;
> unsigned long time_in_queue;
>};
>
>struct hd_struct {
> sector_t start_sect;
> sector_t nr_sects;
> struct device dev;
> struct kobject *holder_dir;
> int policy, partno;
>
>
>
> unsigned long stamp;
> int in_flight;
>
>
>
> struct disk_stats dkstats;
>
>};
># 114 "include/linux/genhd.h"
>struct gendisk {
> int major;
> int first_minor;
> int minors;
>
> char disk_name[32];
> struct hd_struct **part;
> struct block_device_operations *fops;
> struct request_queue *queue;
> void *private_data;
> sector_t capacity;
>
> int flags;
> struct device *driverfs_dev;
> struct device dev;
> struct kobject *holder_dir;
> struct kobject *slave_dir;
>
> struct timer_rand_state *random;
> int policy;
>
> atomic_t sync_io;
> unsigned long stamp;
> int in_flight;
>
>
>
> struct disk_stats dkstats;
>
> struct work_struct async_notify;
>};
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) struct hd_struct *get_part(struct gendisk *gendiskp,
>      sector_t sector)
>{
> struct hd_struct *part;
> int i;
> for (i = 0; i < gendiskp->minors - 1; i++) {
>  part = gendiskp->part[i];
>  if (part && part->start_sect <= sector
>      && sector < part->start_sect + part->nr_sects)
>   return part;
> }
> return ((void *)0);
>}
># 220 "include/linux/genhd.h"
>static inline __attribute__((always_inline)) void disk_stat_set_all(struct gendisk *gendiskp, int value)
>{
> memset(&gendiskp->dkstats, value, sizeof (struct disk_stats));
>}
># 237 "include/linux/genhd.h"
>static inline __attribute__((always_inline)) void part_stat_set_all(struct hd_struct *part, int value)
>{
> memset(&part->dkstats, value, sizeof(struct disk_stats));
>}
># 331 "include/linux/genhd.h"
>static inline __attribute__((always_inline)) int init_disk_stats(struct gendisk *disk)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) void free_disk_stats(struct gendisk *disk)
>{
>}
>
>static inline __attribute__((always_inline)) int init_part_stats(struct hd_struct *part)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) void free_part_stats(struct hd_struct *part)
>{
>}
>
>
>
>extern void disk_round_stats(struct gendisk *disk);
>extern void part_round_stats(struct hd_struct *part);
>
>
>extern int get_blkdev_list(char *, int);
>extern void add_disk(struct gendisk *disk);
>extern void del_gendisk(struct gendisk *gp);
>extern void unlink_gendisk(struct gendisk *gp);
>extern struct gendisk *get_gendisk(dev_t dev, int *part);
>
>extern void set_device_ro(struct block_device *bdev, int flag);
>extern void set_disk_ro(struct gendisk *disk, int flag);
>
>
>extern void add_disk_randomness(struct gendisk *disk);
>extern void rand_initialize_disk(struct gendisk *disk);
>
>static inline __attribute__((always_inline)) sector_t get_start_sect(struct block_device *bdev)
>{
> return bdev->bd_contains == bdev ? 0 : bdev->bd_part->start_sect;
>}
>static inline __attribute__((always_inline)) sector_t get_capacity(struct gendisk *disk)
>{
> return disk->capacity;
>}
>static inline __attribute__((always_inline)) void set_capacity(struct gendisk *disk, sector_t size)
>{
> disk->capacity = size;
>}
># 528 "include/linux/genhd.h"
>extern dev_t blk_lookup_devt(const char *name, int part);
>extern char *disk_name (struct gendisk *hd, int part, char *buf);
>
>extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
>extern void add_partition(struct gendisk *, int, sector_t, sector_t, int);
>extern void delete_partition(struct gendisk *, int);
>extern void printk_all_partitions(void);
>
>extern struct gendisk *alloc_disk_node(int minors, int node_id);
>extern struct gendisk *alloc_disk(int minors);
>extern struct kobject *get_disk(struct gendisk *disk);
>extern void put_disk(struct gendisk *disk);
>extern void blk_register_region(dev_t devt, unsigned long range,
>   struct module *module,
>   struct kobject *(*probe)(dev_t, int *, void *),
>   int (*lock)(dev_t, void *),
>   void *data);
>extern void blk_unregister_region(dev_t devt, unsigned long range);
>
>static inline __attribute__((always_inline)) struct block_device *bdget_disk(struct gendisk *disk, int index)
>{
> return bdget((((disk->major) << 20) | (disk->first_minor)) + index);
>}
># 9 "include/linux/blkdev.h" 2
>
>
>
>
># 1 "include/linux/pagemap.h" 1
># 23 "include/linux/pagemap.h"
>static inline __attribute__((always_inline)) void mapping_set_error(struct address_space *mapping, int error)
>{
> if (error) {
>  if (error == -28)
>   set_bit((21 + 1), &mapping->flags);
>  else
>   set_bit((21 + 0), &mapping->flags);
> }
>}
>
>static inline __attribute__((always_inline)) gfp_t mapping_gfp_mask(struct address_space * mapping)
>{
> return ( gfp_t)mapping->flags & (( gfp_t)((1 << 21) - 1));
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
>{
> m->flags = (m->flags & ~( unsigned long)(( gfp_t)((1 << 21) - 1))) |
>    ( unsigned long)mask;
>}
># 63 "include/linux/pagemap.h"
>void release_pages(struct page **pages, int nr, int cold);
>
>
>
>
>static inline __attribute__((always_inline)) struct page *__page_cache_alloc(gfp_t gfp)
>{
> return alloc_pages_node((((void)(0),0)), gfp, 0);
>}
>
>
>static inline __attribute__((always_inline)) struct page *page_cache_alloc(struct address_space *x)
>{
> return __page_cache_alloc(mapping_gfp_mask(x));
>}
>
>static inline __attribute__((always_inline)) struct page *page_cache_alloc_cold(struct address_space *x)
>{
> return __page_cache_alloc(mapping_gfp_mask(x)|(( gfp_t)0x100u));
>}
>
>typedef int filler_t(void *, struct page *);
>
>extern struct page * find_get_page(struct address_space *mapping,
>    unsigned long index);
>extern struct page * find_lock_page(struct address_space *mapping,
>    unsigned long index);
>extern struct page * find_or_create_page(struct address_space *mapping,
>    unsigned long index, gfp_t gfp_mask);
>unsigned find_get_pages(struct address_space *mapping, unsigned long start,
>   unsigned int nr_pages, struct page **pages);
>unsigned find_get_pages_contig(struct address_space *mapping, unsigned long start,
>          unsigned int nr_pages, struct page **pages);
>unsigned find_get_pages_tag(struct address_space *mapping, unsigned long *index,
>   int tag, unsigned int nr_pages, struct page **pages);
>
>struct page *__grab_cache_page(struct address_space *mapping, unsigned long index);
>
>
>
>
>static inline __attribute__((always_inline)) struct page *grab_cache_page(struct address_space *mapping,
>        unsigned long index)
>{
> return find_or_create_page(mapping, index, mapping_gfp_mask(mapping));
>}
>
>extern struct page * grab_cache_page_nowait(struct address_space *mapping,
>    unsigned long index);
>extern struct page * read_cache_page_async(struct address_space *mapping,
>    unsigned long index, filler_t *filler,
>    void *data);
>extern struct page * read_cache_page(struct address_space *mapping,
>    unsigned long index, filler_t *filler,
>    void *data);
>extern int read_cache_pages(struct address_space *mapping,
>  struct list_head *pages, filler_t *filler, void *data);
>
>static inline __attribute__((always_inline)) struct page *read_mapping_page_async(
>      struct address_space *mapping,
>           unsigned long index, void *data)
>{
> filler_t *filler = (filler_t *)mapping->a_ops->readpage;
> return read_cache_page_async(mapping, index, filler, data);
>}
>
>static inline __attribute__((always_inline)) struct page *read_mapping_page(struct address_space *mapping,
>          unsigned long index, void *data)
>{
> filler_t *filler = (filler_t *)mapping->a_ops->readpage;
> return read_cache_page(mapping, index, filler, data);
>}
>
>int add_to_page_cache(struct page *page, struct address_space *mapping,
>    unsigned long index, gfp_t gfp_mask);
>int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
>    unsigned long index, gfp_t gfp_mask);
>extern void remove_from_page_cache(struct page *page);
>extern void __remove_from_page_cache(struct page *page);
>
>
>
>
>static inline __attribute__((always_inline)) loff_t page_offset(struct page *page)
>{
> return ((loff_t)page->index) << 12;
>}
>
>static inline __attribute__((always_inline)) unsigned long linear_page_index(struct vm_area_struct *vma,
>     unsigned long address)
>{
> unsigned long pgoff = (address - vma->vm_start) >> 12;
> pgoff += vma->vm_pgoff;
> return pgoff >> (12 - 12);
>}
>
>extern void __lock_page(struct page *page);
>extern int __lock_page_killable(struct page *page);
>extern void __lock_page_nosync(struct page *page);
>extern void unlock_page(struct page *page);
>
>
>
>
>static inline __attribute__((always_inline)) void lock_page(struct page *page)
>{
> do { do { } while (0); } while (0);
> if (TestSetPageLocked(page))
>  __lock_page(page);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int lock_page_killable(struct page *page)
>{
> do { do { } while (0); } while (0);
> if (TestSetPageLocked(page))
>  return __lock_page_killable(page);
> return 0;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void lock_page_nosync(struct page *page)
>{
> do { do { } while (0); } while (0);
> if (TestSetPageLocked(page))
>  __lock_page_nosync(page);
>}
>
>
>
>
>
>extern void wait_on_page_bit(struct page *page, int bit_nr);
># 211 "include/linux/pagemap.h"
>static inline __attribute__((always_inline)) void wait_on_page_locked(struct page *page)
>{
> if (PageLocked(page))
>  wait_on_page_bit(page, PG_locked);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void wait_on_page_writeback(struct page *page)
>{
> if (PageWriteback(page))
>  wait_on_page_bit(page, PG_writeback);
>}
>
>extern void end_page_writeback(struct page *page);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int fault_in_pages_writeable(char *uaddr, int size)
>{
> int ret;
>
> if (__builtin_expect(!!(size == 0), 0))
>  return 0;
>
>
>
>
>
> ret = ({ __typeof__(*(uaddr)) *__private_ptr = uaddr; __typeof__(*(__private_ptr)) __private_val; int __private_ret = -14; __private_val = (__typeof__(*(__private_ptr))) (0); if (copy_to_user((__private_ptr), &__private_val, sizeof(*(__private_ptr))) == 0) { __private_ret = 0; } __private_ret; });
> if (ret == 0) {
>  char *end = uaddr + size - 1;
>
>
>
>
>
>  if (((unsigned long)uaddr & (~(((1UL) << 12)-1))) !=
>    ((unsigned long)end & (~(((1UL) << 12)-1))))
>    ret = ({ __typeof__(*(end)) *__private_ptr = end; __typeof__(*(__private_ptr)) __private_val; int __private_ret = -14; __private_val = (__typeof__(*(__private_ptr))) (0); if (copy_to_user((__private_ptr), &__private_val, sizeof(*(__private_ptr))) == 0) { __private_ret = 0; } __private_ret; });
> }
> return ret;
>}
>
>static inline __attribute__((always_inline)) int fault_in_pages_readable(const char *uaddr, int size)
>{
> volatile char c;
> int ret;
>
> if (__builtin_expect(!!(size == 0), 0))
>  return 0;
>
> ret = ({ const __typeof__(*(uaddr)) *__private_ptr = (uaddr); __typeof__(c) __private_val; int __private_ret = -14; (c) = (__typeof__(*(__private_ptr)))0; if (copy_from_user(( void *)&__private_val, (__private_ptr), sizeof(*(__private_ptr))) == 0) { (c) = (__typeof__(*(__private_ptr))) __private_val; __private_ret = 0; } __private_ret; });
> if (ret == 0) {
>  const char *end = uaddr + size - 1;
>
>  if (((unsigned long)uaddr & (~(((1UL) << 12)-1))) !=
>    ((unsigned long)end & (~(((1UL) << 12)-1))))
>    ret = ({ const __typeof__(*(end)) *__private_ptr = (end); __typeof__(c) __private_val; int __private_ret = -14; (c) = (__typeof__(*(__private_ptr)))0; if (copy_from_user(( void *)&__private_val, (__private_ptr), sizeof(*(__private_ptr))) == 0) { (c) = (__typeof__(*(__private_ptr))) __private_val; __private_ret = 0; } __private_ret; });
> }
> return ret;
>}
># 13 "include/linux/blkdev.h" 2
>
># 1 "include/linux/backing-dev.h" 1
># 18 "include/linux/backing-dev.h"
>struct page;
>struct device;
>struct dentry;
>
>
>
>
>enum bdi_state {
> BDI_pdflush,
> BDI_write_congested,
> BDI_read_congested,
> BDI_unused,
>};
>
>typedef int (congested_fn)(void *, int);
>
>enum bdi_stat_item {
> BDI_RECLAIMABLE,
> BDI_WRITEBACK,
> NR_BDI_STAT_ITEMS
>};
>
>
>
>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;
>
> struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
>
> struct prop_local_percpu completions;
> int dirty_exceeded;
>
> unsigned int min_ratio;
> unsigned int max_ratio, max_prop_frac;
>
> struct device *dev;
>
>
>
>
>
>};
>
>int bdi_init(struct backing_dev_info *bdi);
>void bdi_destroy(struct backing_dev_info *bdi);
>
>int bdi_register(struct backing_dev_info *bdi, struct device *parent,
>  const char *fmt, ...);
>int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
>void bdi_unregister(struct backing_dev_info *bdi);
>
>static inline __attribute__((always_inline)) void __add_bdi_stat(struct backing_dev_info *bdi,
>  enum bdi_stat_item item, s64 amount)
>{
> percpu_counter_add(&bdi->bdi_stat[item], amount);
>}
>
>static inline __attribute__((always_inline)) void __inc_bdi_stat(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> __add_bdi_stat(bdi, item, 1);
>}
>
>static inline __attribute__((always_inline)) void inc_bdi_stat(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0);
> __inc_bdi_stat(bdi, item);
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0);
>}
>
>static inline __attribute__((always_inline)) void __dec_bdi_stat(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> __add_bdi_stat(bdi, item, -1);
>}
>
>static inline __attribute__((always_inline)) void dec_bdi_stat(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0);
> __dec_bdi_stat(bdi, item);
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0);
>}
>
>static inline __attribute__((always_inline)) s64 bdi_stat(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> return percpu_counter_read_positive(&bdi->bdi_stat[item]);
>}
>
>static inline __attribute__((always_inline)) s64 __bdi_stat_sum(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
>}
>
>static inline __attribute__((always_inline)) s64 bdi_stat_sum(struct backing_dev_info *bdi,
>  enum bdi_stat_item item)
>{
> s64 sum;
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0);
> sum = __bdi_stat_sum(bdi, item);
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0);
>
> return sum;
>}
>
>extern void bdi_writeout_inc(struct backing_dev_info *bdi);
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long bdi_stat_error(struct backing_dev_info *bdi)
>{
>
>
>
> return 1;
>
>}
>
>int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
>int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
># 201 "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_in_progress(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);
>
>
>static inline __attribute__((always_inline)) bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
>{
> return !(bdi->capabilities & 0x00000002);
>}
>
>static inline __attribute__((always_inline)) bool bdi_cap_account_dirty(struct backing_dev_info *bdi)
>{
> return !(bdi->capabilities & 0x00000001);
>}
>
>static inline __attribute__((always_inline)) bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
>{
>
> return !(bdi->capabilities & (0x00000080 |
>          0x00000002));
>}
>
>static inline __attribute__((always_inline)) bool mapping_cap_writeback_dirty(struct address_space *mapping)
>{
> return bdi_cap_writeback_dirty(mapping->backing_dev_info);
>}
>
>static inline __attribute__((always_inline)) bool mapping_cap_account_dirty(struct address_space *mapping)
>{
> return bdi_cap_account_dirty(mapping->backing_dev_info);
>}
># 14 "include/linux/blkdev.h" 2
>
>
># 1 "include/linux/mempool.h" 1
># 9 "include/linux/mempool.h"
>struct kmem_cache;
>
>typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data);
>typedef void (mempool_free_t)(void *element, void *pool_data);
>
>typedef struct mempool_s {
> spinlock_t lock;
> int min_nr;
> int curr_nr;
> void **elements;
>
> void *pool_data;
> mempool_alloc_t *alloc;
> mempool_free_t *free;
> wait_queue_head_t wait;
>} mempool_t;
>
>extern mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
>   mempool_free_t *free_fn, void *pool_data);
>extern mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
>   mempool_free_t *free_fn, void *pool_data, int nid);
>
>extern int mempool_resize(mempool_t *pool, int new_min_nr, gfp_t gfp_mask);
>extern void mempool_destroy(mempool_t *pool);
>extern void * mempool_alloc(mempool_t *pool, gfp_t gfp_mask);
>extern void mempool_free(void *element, mempool_t *pool);
>
>
>
>
>
>void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data);
>void mempool_free_slab(void *element, void *pool_data);
>static inline __attribute__((always_inline)) mempool_t *
>mempool_create_slab_pool(int min_nr, struct kmem_cache *kc)
>{
> return mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
>         (void *) kc);
>}
>
>
>
>
>
>void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data);
>void *mempool_kzalloc(gfp_t gfp_mask, void *pool_data);
>void mempool_kfree(void *element, void *pool_data);
>static inline __attribute__((always_inline)) mempool_t *mempool_create_kmalloc_pool(int min_nr, size_t size)
>{
> return mempool_create(min_nr, mempool_kmalloc, mempool_kfree,
>         (void *) size);
>}
>static inline __attribute__((always_inline)) mempool_t *mempool_create_kzalloc_pool(int min_nr, size_t size)
>{
> return mempool_create(min_nr, mempool_kzalloc, mempool_kfree,
>         (void *) size);
>}
>
>
>
>
>
>void *mempool_alloc_pages(gfp_t gfp_mask, void *pool_data);
>void mempool_free_pages(void *element, void *pool_data);
>static inline __attribute__((always_inline)) mempool_t *mempool_create_page_pool(int min_nr, int order)
>{
> return mempool_create(min_nr, mempool_alloc_pages, mempool_free_pages,
>         (void *)(long)order);
>}
># 16 "include/linux/blkdev.h" 2
>
># 1 "include/linux/bio.h" 1
># 25 "include/linux/bio.h"
>
># 1 "include/linux/ioprio.h" 1
>
>
>
>
>
># 1 "include/linux/iocontext.h" 1
># 10 "include/linux/iocontext.h"
>struct as_io_context {
> spinlock_t lock;
>
> void (*dtor)(struct as_io_context *aic);
> void (*exit)(struct as_io_context *aic);
>
> unsigned long state;
> atomic_t nr_queued;
> atomic_t nr_dispatched;
>
>
>
> unsigned long last_end_request;
> unsigned long ttime_total;
> unsigned long ttime_samples;
> unsigned long ttime_mean;
>
> unsigned int seek_samples;
> sector_t last_request_pos;
> u64 seek_total;
> sector_t seek_mean;
>};
>
>struct cfq_queue;
>struct cfq_io_context {
> void *key;
> unsigned long dead_key;
>
> struct cfq_queue *cfqq[2];
>
> struct io_context *ioc;
>
> unsigned long last_end_request;
> sector_t last_request_pos;
>
> unsigned long ttime_total;
> unsigned long ttime_samples;
> unsigned long ttime_mean;
>
> unsigned int seek_samples;
> u64 seek_total;
> sector_t seek_mean;
>
> struct list_head queue_list;
> struct hlist_node cic_list;
>
> void (*dtor)(struct io_context *);
> void (*exit)(struct io_context *);
>
> struct rcu_head rcu_head;
>};
>
>
>
>
>
>struct io_context {
> atomic_t refcount;
> atomic_t nr_tasks;
>
>
> spinlock_t lock;
>
> unsigned short ioprio;
> unsigned short ioprio_changed;
>
>
>
>
> unsigned long last_waited;
> int nr_batch_requests;
>
> struct as_io_context *aic;
> struct radix_tree_root radix_root;
> struct hlist_head cic_list;
> void *ioc_data;
>};
>
>static inline __attribute__((always_inline)) struct io_context *ioc_task_link(struct io_context *ioc)
>{
>
>
>
>
> if (ioc && atomic_add_unless((&ioc->refcount), 1, 0)) {
>  atomic_inc(&ioc->nr_tasks);
>  return ioc;
> }
>
> return ((void *)0);
>}
># 6 "include/linux/ioprio.h" 2
># 26 "include/linux/ioprio.h"
>enum {
> IOPRIO_CLASS_NONE,
> IOPRIO_CLASS_RT,
> IOPRIO_CLASS_BE,
> IOPRIO_CLASS_IDLE,
>};
>
>
>
>
>
>
>enum {
> IOPRIO_WHO_PROCESS = 1,
> IOPRIO_WHO_PGRP,
> IOPRIO_WHO_USER,
>};
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int task_ioprio(struct io_context *ioc)
>{
> if (((((ioc->ioprio)) >> (13)) != IOPRIO_CLASS_NONE))
>  return ((ioc->ioprio) & ((1UL << (13)) - 1));
>
> return (4);
>}
>
>static inline __attribute__((always_inline)) int task_ioprio_class(struct io_context *ioc)
>{
> if (((((ioc->ioprio)) >> (13)) != IOPRIO_CLASS_NONE))
>  return ((ioc->ioprio) >> (13));
>
> return IOPRIO_CLASS_BE;
>}
>
>static inline __attribute__((always_inline)) int task_nice_ioprio(struct task_struct *task)
>{
> return (task_nice(task) + 20) / 5;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int task_nice_ioclass(struct task_struct *task)
>{
> if (task->policy == 5)
>  return IOPRIO_CLASS_IDLE;
> else if (task->policy == 1 || task->policy == 2)
>  return IOPRIO_CLASS_RT;
> else
>  return IOPRIO_CLASS_BE;
>}
>
>
>
>
>extern int ioprio_best(unsigned short aprio, unsigned short bprio);
># 26 "include/linux/bio.h" 2
>
>
>
>
>
># 1 "include/asm/io.h" 1
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int inb(unsigned long i) { return(0); }
>static inline __attribute__((always_inline)) void outb(char c, unsigned long i) { }
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long virt_to_phys(volatile void * address)
>{
> return to_phys((void *) (unsigned long) ((void *) address));
>}
>
>static inline __attribute__((always_inline)) void * phys_to_virt(unsigned long address)
>{
> return to_virt((unsigned long) (address));
>}
># 36 "include/asm/io.h"
>static inline __attribute__((always_inline)) void writeb(unsigned char b, volatile void *addr)
>{
> *(volatile unsigned char *) addr = b;
>}
>static inline __attribute__((always_inline)) void writew(unsigned short b, volatile void *addr)
>{
> *(volatile unsigned short *) addr = b;
>}
>static inline __attribute__((always_inline)) void writel(unsigned int b, volatile void *addr)
>{
> *(volatile unsigned int *) addr = b;
>}
>static inline __attribute__((always_inline)) void writeq(unsigned int b, volatile void *addr)
>{
> *(volatile unsigned long long *) addr = b;
>}
># 31 "include/linux/bio.h" 2
># 59 "include/linux/bio.h"
>struct bio_vec {
> struct page *bv_page;
> unsigned int bv_len;
> unsigned int bv_offset;
>};
>
>struct bio_set;
>struct bio;
>typedef void (bio_end_io_t) (struct bio *, int);
>typedef void (bio_destructor_t) (struct bio *);
>
>
>
>
>
>struct bio {
> sector_t bi_sector;
>
> struct bio *bi_next;
> struct block_device *bi_bdev;
> unsigned long bi_flags;
> unsigned long bi_rw;
>
>
>
> unsigned short bi_vcnt;
> unsigned short bi_idx;
>
>
>
>
> unsigned short bi_phys_segments;
>
>
>
>
> unsigned short bi_hw_segments;
>
> unsigned int bi_size;
>
>
>
>
>
>
> unsigned int bi_hw_front_size;
> unsigned int bi_hw_back_size;
>
> unsigned int bi_max_vecs;
>
> struct bio_vec *bi_io_vec;
>
> bio_end_io_t *bi_end_io;
> atomic_t bi_cnt;
>
> void *bi_private;
>
> bio_destructor_t *bi_destructor;
>};
># 186 "include/linux/bio.h"
>static inline __attribute__((always_inline)) unsigned int bio_cur_sectors(struct bio *bio)
>{
> if (bio->bi_vcnt)
>  return (&(((bio))->bi_io_vec[((bio)->bi_idx)]))->bv_len >> 9;
>
> return 0;
>}
>
>static inline __attribute__((always_inline)) void *bio_data(struct bio *bio)
>{
> if (bio->bi_vcnt)
>  return lowmem_page_address((&((((bio)))->bi_io_vec[(((bio))->bi_idx)]))->bv_page) + (&((((bio)))->bi_io_vec[(((bio))->bi_idx)]))->bv_offset;
>
> return ((void *)0);
>}
># 285 "include/linux/bio.h"
>struct bio_pair {
> struct bio bio1, bio2;
> struct bio_vec bv1, bv2;
> atomic_t cnt;
> int error;
>};
>extern struct bio_pair *bio_split(struct bio *bi, mempool_t *pool,
>      int first_sectors);
>extern mempool_t *bio_split_pool;
>extern void bio_pair_release(struct bio_pair *dbio);
>
>extern struct bio_set *bioset_create(int, int);
>extern void bioset_free(struct bio_set *);
>
>extern struct bio *bio_alloc(gfp_t, int);
>extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
>extern void bio_put(struct bio *);
>extern void bio_free(struct bio *, struct bio_set *);
>
>extern void bio_endio(struct bio *, int);
>struct request_queue;
>extern int bio_phys_segments(struct request_queue *, struct bio *);
>extern int bio_hw_segments(struct request_queue *, struct bio *);
>
>extern void __bio_clone(struct bio *, struct bio *);
>extern struct bio *bio_clone(struct bio *, gfp_t);
>
>extern void bio_init(struct bio *);
>
>extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
>extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
>      unsigned int, unsigned int);
>extern int bio_get_nr_vecs(struct block_device *);
>extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
>    unsigned long, unsigned int, int);
>struct sg_iovec;
>extern struct bio *bio_map_user_iov(struct request_queue *,
>        struct block_device *,
>        struct sg_iovec *, int, int);
>extern void bio_unmap_user(struct bio *);
>extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
>    gfp_t);
>extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
>     gfp_t, int);
>extern void bio_set_pages_dirty(struct bio *bio);
>extern void bio_check_pages_dirty(struct bio *bio);
>extern struct bio *bio_copy_user(struct request_queue *, unsigned long, unsigned int, int);
>extern struct bio *bio_copy_user_iov(struct request_queue *, struct sg_iovec *,
>         int, int);
>extern int bio_uncopy_user(struct bio *);
>void zero_fill_bio(struct bio *bio);
># 373 "include/linux/bio.h"
>static inline __attribute__((always_inline)) char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
>       unsigned long *flags)
>{
> return (lowmem_page_address(((&((bio)->bi_io_vec[(idx)])))->bv_page) + ((&((bio)->bi_io_vec[(idx)])))->bv_offset);
>}
># 17 "include/linux/blkdev.h" 2
>
>
>
># 1 "include/linux/bsg.h" 1
># 10 "include/linux/bsg.h"
>struct sg_io_v4 {
> __s32 guard;
> __u32 protocol;
> __u32 subprotocol;
>
>
> __u32 request_len;
> __u64 request;
> __u64 request_tag;
> __u32 request_attr;
> __u32 request_priority;
> __u32 request_extra;
> __u32 max_response_len;
> __u64 response;
>
>
> __u32 dout_iovec_count;
>
> __u32 dout_xfer_len;
> __u32 din_iovec_count;
> __u32 din_xfer_len;
> __u64 dout_xferp;
> __u64 din_xferp;
>
> __u32 timeout;
> __u32 flags;
> __u64 usr_ptr;
> __u32 spare_in;
>
> __u32 driver_status;
> __u32 transport_status;
> __u32 device_status;
> __u32 retry_delay;
> __u32 info;
> __u32 duration;
> __u32 response_len;
> __s32 din_resid;
> __s32 dout_resid;
> __u64 generated_tag;
> __u32 spare_out;
>
> __u32 padding;
>};
># 71 "include/linux/bsg.h"
>static inline __attribute__((always_inline)) int bsg_register_queue(struct request_queue *q,
>         struct device *parent, const char *name,
>         void (*release)(struct device *))
>{
> return 0;
>}
>static inline __attribute__((always_inline)) void bsg_unregister_queue(struct request_queue *q)
>{
>}
># 20 "include/linux/blkdev.h" 2
>
>
># 1 "include/asm/scatterlist.h" 1
>
>
>
>
># 1 "include/asm/arch/scatterlist.h" 1
>
>
>
>
>
>struct scatterlist {
>
>
>
> unsigned long page_link;
> unsigned int offset;
> unsigned int length;
> dma_addr_t dma_address;
> unsigned int dma_length;
>};
># 5 "include/asm/scatterlist.h" 2
># 22 "include/linux/blkdev.h" 2
>
>struct scsi_ioctl_command;
>
>struct request_queue;
>typedef struct request_queue request_queue_t __attribute__((deprecated));
>struct elevator_queue;
>typedef struct elevator_queue elevator_t;
>struct request_pm_state;
>struct blk_trace;
>struct request;
>struct sg_io_hdr;
>
>
>
>
>int put_io_context(struct io_context *ioc);
>void exit_io_context(void);
>struct io_context *get_io_context(gfp_t gfp_flags, int node);
>struct io_context *alloc_io_context(gfp_t gfp_flags, int node);
>void copy_io_context(struct io_context **pdst, struct io_context **psrc);
>
>struct request;
>typedef void (rq_end_io_fn)(struct request *, int);
>
>struct request_list {
> int count[2];
> int starved[2];
> int elvpriv;
> mempool_t *rq_pool;
> wait_queue_head_t wait[2];
>};
>
>
>
>
>enum rq_cmd_type_bits {
> REQ_TYPE_FS = 1,
> REQ_TYPE_BLOCK_PC,
> REQ_TYPE_SENSE,
> REQ_TYPE_PM_SUSPEND,
> REQ_TYPE_PM_RESUME,
> REQ_TYPE_PM_SHUTDOWN,
> REQ_TYPE_FLUSH,
> REQ_TYPE_SPECIAL,
> REQ_TYPE_LINUX_BLOCK,
>
>
>
>
>
> REQ_TYPE_ATA_TASKFILE,
> REQ_TYPE_ATA_PC,
>};
># 85 "include/linux/blkdev.h"
>enum {
>
>
>
> REQ_LB_OP_EJECT = 0x40,
> REQ_LB_OP_FLUSH = 0x41,
>};
>
>
>
>
>enum rq_flag_bits {
> __REQ_RW,
> __REQ_FAILFAST,
> __REQ_SORTED,
> __REQ_SOFTBARRIER,
> __REQ_HARDBARRIER,
> __REQ_FUA,
> __REQ_NOMERGE,
> __REQ_STARTED,
> __REQ_DONTPREP,
> __REQ_QUEUED,
> __REQ_ELVPRIV,
> __REQ_FAILED,
> __REQ_QUIET,
> __REQ_PREEMPT,
> __REQ_ORDERED_COLOR,
> __REQ_RW_SYNC,
> __REQ_ALLOCED,
> __REQ_RW_META,
> __REQ_COPY_USER,
> __REQ_NR_BITS,
>};
># 146 "include/linux/blkdev.h"
>struct request {
> struct list_head queuelist;
> struct list_head donelist;
>
> struct request_queue *q;
>
> unsigned int cmd_flags;
> enum rq_cmd_type_bits cmd_type;
>
>
>
>
>
> sector_t sector;
> sector_t hard_sector;
> unsigned long nr_sectors;
> unsigned long hard_nr_sectors;
>
> unsigned int current_nr_sectors;
>
>
> unsigned int hard_cur_sectors;
>
> struct bio *bio;
> struct bio *biotail;
>
> struct hlist_node hash;
>
>
>
>
>
> union {
>  struct rb_node rb_node;
>  void *completion_data;
> };
>
>
>
>
>
> void *elevator_private;
> void *elevator_private2;
>
> struct gendisk *rq_disk;
> unsigned long start_time;
>
>
>
>
> unsigned short nr_phys_segments;
>
>
>
>
>
>
> unsigned short nr_hw_segments;
>
> unsigned short ioprio;
>
> void *special;
> char *buffer;
>
> int tag;
> int errors;
>
> int ref_count;
>
>
>
>
> unsigned short cmd_len;
> unsigned char __cmd[16];
> unsigned char *cmd;
>
> unsigned int data_len;
> unsigned int extra_len;
> unsigned int sense_len;
> void *data;
> void *sense;
>
> unsigned int timeout;
> int retries;
>
>
>
>
> rq_end_io_fn *end_io;
> void *end_io_data;
>
>
> struct request *next_rq;
>};
>
>
>
>
>
>struct request_pm_state
>{
>
> int pm_step;
>
> u32 pm_state;
> void* data;
>};
>
>
># 1 "include/linux/elevator.h" 1
>
>
>
>
>
>
>
>typedef int (elevator_merge_fn) (struct request_queue *, struct request **,
>     struct bio *);
>
>typedef void (elevator_merge_req_fn) (struct request_queue *, struct request *, struct request *);
>
>typedef void (elevator_merged_fn) (struct request_queue *, struct request *, int);
>
>typedef int (elevator_allow_merge_fn) (struct request_queue *, struct request *, struct bio *);
>
>typedef int (elevator_dispatch_fn) (struct request_queue *, int);
>
>typedef void (elevator_add_req_fn) (struct request_queue *, struct request *);
>typedef int (elevator_queue_empty_fn) (struct request_queue *);
>typedef struct request *(elevator_request_list_fn) (struct request_queue *, struct request *);
>typedef void (elevator_completed_req_fn) (struct request_queue *, struct request *);
>typedef int (elevator_may_queue_fn) (struct request_queue *, int);
>
>typedef int (elevator_set_req_fn) (struct request_queue *, struct request *, gfp_t);
>typedef void (elevator_put_req_fn) (struct request *);
>typedef void (elevator_activate_req_fn) (struct request_queue *, struct request *);
>typedef void (elevator_deactivate_req_fn) (struct request_queue *, struct request *);
>
>typedef void *(elevator_init_fn) (struct request_queue *);
>typedef void (elevator_exit_fn) (elevator_t *);
>
>struct elevator_ops
>{
> elevator_merge_fn *elevator_merge_fn;
> elevator_merged_fn *elevator_merged_fn;
> elevator_merge_req_fn *elevator_merge_req_fn;
> elevator_allow_merge_fn *elevator_allow_merge_fn;
>
> elevator_dispatch_fn *elevator_dispatch_fn;
> elevator_add_req_fn *elevator_add_req_fn;
> elevator_activate_req_fn *elevator_activate_req_fn;
> elevator_deactivate_req_fn *elevator_deactivate_req_fn;
>
> elevator_queue_empty_fn *elevator_queue_empty_fn;
> elevator_completed_req_fn *elevator_completed_req_fn;
>
> elevator_request_list_fn *elevator_former_req_fn;
> elevator_request_list_fn *elevator_latter_req_fn;
>
> elevator_set_req_fn *elevator_set_req_fn;
> elevator_put_req_fn *elevator_put_req_fn;
>
> elevator_may_queue_fn *elevator_may_queue_fn;
>
> elevator_init_fn *elevator_init_fn;
> elevator_exit_fn *elevator_exit_fn;
> void (*trim)(struct io_context *);
>};
>
>
>
>struct elv_fs_entry {
> struct attribute attr;
> ssize_t (*show)(elevator_t *, char *);
> ssize_t (*store)(elevator_t *, const char *, size_t);
>};
>
>
>
>
>struct elevator_type
>{
> struct list_head list;
> struct elevator_ops ops;
> struct elv_fs_entry *elevator_attrs;
> char elevator_name[(16)];
> struct module *elevator_owner;
>};
>
>
>
>
>struct elevator_queue
>{
> struct elevator_ops *ops;
> void *elevator_data;
> struct kobject kobj;
> struct elevator_type *elevator_type;
> struct mutex sysfs_lock;
> struct hlist_head *hash;
>};
>
>
>
>
>extern void elv_dispatch_sort(struct request_queue *, struct request *);
>extern void elv_dispatch_add_tail(struct request_queue *, struct request *);
>extern void elv_add_request(struct request_queue *, struct request *, int, int);
>extern void __elv_add_request(struct request_queue *, struct request *, int, int);
>extern void elv_insert(struct request_queue *, struct request *, int);
>extern int elv_merge(struct request_queue *, struct request **, struct bio *);
>extern void elv_merge_requests(struct request_queue *, struct request *,
>          struct request *);
>extern void elv_merged_request(struct request_queue *, struct request *, int);
>extern void elv_dequeue_request(struct request_queue *, struct request *);
>extern void elv_requeue_request(struct request_queue *, struct request *);
>extern int elv_queue_empty(struct request_queue *);
>extern struct request *elv_next_request(struct request_queue *q);
>extern struct request *elv_former_request(struct request_queue *, struct request *);
>extern struct request *elv_latter_request(struct request_queue *, struct request *);
>extern int elv_register_queue(struct request_queue *q);
>extern void elv_unregister_queue(struct request_queue *q);
>extern int elv_may_queue(struct request_queue *, int);
>extern void elv_completed_request(struct request_queue *, struct request *);
>extern int elv_set_request(struct request_queue *, struct request *, gfp_t);
>extern void elv_put_request(struct request_queue *, struct request *);
>
>
>
>
>extern void elv_register(struct elevator_type *);
>extern void elv_unregister(struct elevator_type *);
>
>
>
>
>extern ssize_t elv_iosched_show(struct request_queue *, char *);
>extern ssize_t elv_iosched_store(struct request_queue *, const char *, size_t);
>
>extern int elevator_init(struct request_queue *, char *);
>extern void elevator_exit(elevator_t *);
>extern int elv_rq_merge_ok(struct request *, struct bio *);
>
>
>
>
>extern struct request *elv_rb_former_request(struct request_queue *, struct request *);
>extern struct request *elv_rb_latter_request(struct request_queue *, struct request *);
>
>
>
>
>extern struct request *elv_rb_add(struct rb_root *, struct request *);
>extern void elv_rb_del(struct rb_root *, struct request *);
>extern struct request *elv_rb_find(struct rb_root *, sector_t);
># 166 "include/linux/elevator.h"
>enum {
> ELV_MQUEUE_MAY,
> ELV_MQUEUE_NO,
> ELV_MQUEUE_MUST,
>};
># 255 "include/linux/blkdev.h" 2
>
>typedef void (request_fn_proc) (struct request_queue *q);
>typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
>typedef int (prep_rq_fn) (struct request_queue *, struct request *);
>typedef void (unplug_fn) (struct request_queue *);
>
>struct bio_vec;
>typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *);
>typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
>typedef void (softirq_done_fn)(struct request *);
>typedef int (dma_drain_needed_fn)(struct request *);
>
>enum blk_queue_state {
> Queue_down,
> Queue_up,
>};
>
>struct blk_queue_tag {
> struct request **tag_index;
> unsigned long *tag_map;
> int busy;
> int max_depth;
> int real_max_depth;
> atomic_t refcnt;
>};
>
>struct request_queue
>{
>
>
>
> struct list_head queue_head;
> struct request *last_merge;
> elevator_t *elevator;
>
>
>
>
> struct request_list rq;
>
> request_fn_proc *request_fn;
> make_request_fn *make_request_fn;
> prep_rq_fn *prep_rq_fn;
> unplug_fn *unplug_fn;
> merge_bvec_fn *merge_bvec_fn;
> prepare_flush_fn *prepare_flush_fn;
> softirq_done_fn *softirq_done_fn;
> dma_drain_needed_fn *dma_drain_needed;
>
>
>
>
> sector_t end_sector;
> struct request *boundary_rq;
>
>
>
>
> struct timer_list unplug_timer;
> int unplug_thresh;
> unsigned long unplug_delay;
> struct work_struct unplug_work;
>
> struct backing_dev_info backing_dev_info;
>
>
>
>
>
> void *queuedata;
>
>
>
>
> unsigned long bounce_pfn;
> gfp_t bounce_gfp;
>
>
>
>
> unsigned long queue_flags;
>
>
>
>
>
>
> spinlock_t __queue_lock;
> spinlock_t *queue_lock;
>
>
>
>
> struct kobject kobj;
>
>
>
>
> unsigned long nr_requests;
> unsigned int nr_congestion_on;
> unsigned int nr_congestion_off;
> unsigned int nr_batching;
>
> unsigned int max_sectors;
> unsigned int max_hw_sectors;
> unsigned short max_phys_segments;
> unsigned short max_hw_segments;
> unsigned short hardsect_size;
> unsigned int max_segment_size;
>
> unsigned long seg_boundary_mask;
> void *dma_drain_buffer;
> unsigned int dma_drain_size;
> unsigned int dma_pad_mask;
> unsigned int dma_alignment;
>
> struct blk_queue_tag *queue_tags;
> struct list_head tag_busy_list;
>
> unsigned int nr_sorted;
> unsigned int in_flight;
>
>
>
>
> unsigned int sg_timeout;
> unsigned int sg_reserved_size;
> int node;
>
>
>
>
>
>
> unsigned int ordered, next_ordered, ordseq;
> int orderr, ordcolor;
> struct request pre_flush_rq, bar_rq, post_flush_rq;
> struct request *orig_bar_rq;
>
> struct mutex sysfs_lock;
>
>
>
>
>};
># 413 "include/linux/blkdev.h"
>static inline __attribute__((always_inline)) int queue_is_locked(struct request_queue *q)
>{
>
>
>
>
> return 1;
>
>}
>
>static inline __attribute__((always_inline)) void queue_flag_set_unlocked(unsigned int flag,
>        struct request_queue *q)
>{
> __set_bit(flag, &q->queue_flags);
>}
>
>static inline __attribute__((always_inline)) void queue_flag_set(unsigned int flag, struct request_queue *q)
>{
> ({ static int __warned; int __ret_warn_once = !!(!queue_is_locked(q)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("include/linux/blkdev.h", 431); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = 1; __builtin_expect(!!(__ret_warn_once), 0); });
> __set_bit(flag, &q->queue_flags);
>}
>
>static inline __attribute__((always_inline)) void queue_flag_clear_unlocked(unsigned int flag,
>          struct request_queue *q)
>{
> __clear_bit(flag, &q->queue_flags);
>}
>
>static inline __attribute__((always_inline)) void queue_flag_clear(unsigned int flag, struct request_queue *q)
>{
> ({ static int __warned; int __ret_warn_once = !!(!queue_is_locked(q)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("include/linux/blkdev.h", 443); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = 1; __builtin_expect(!!(__ret_warn_once), 0); });
> __clear_bit(flag, &q->queue_flags);
>}
>
>enum {
># 459 "include/linux/blkdev.h"
> QUEUE_ORDERED_NONE = 0x00,
> QUEUE_ORDERED_DRAIN = 0x01,
> QUEUE_ORDERED_TAG = 0x02,
>
> QUEUE_ORDERED_PREFLUSH = 0x10,
> QUEUE_ORDERED_POSTFLUSH = 0x20,
> QUEUE_ORDERED_FUA = 0x40,
>
> QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
>   QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
> QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN |
>   QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
> QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG |
>   QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
> QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG |
>   QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
>
>
>
>
> QUEUE_ORDSEQ_STARTED = 0x01,
> QUEUE_ORDSEQ_DRAIN = 0x02,
> QUEUE_ORDSEQ_PREFLUSH = 0x04,
> QUEUE_ORDSEQ_BAR = 0x08,
> QUEUE_ORDSEQ_POSTFLUSH = 0x10,
> QUEUE_ORDSEQ_DONE = 0x20,
>};
># 526 "include/linux/blkdev.h"
>static inline __attribute__((always_inline)) int blk_queue_full(struct request_queue *q, int rw)
>{
> if (rw == 0)
>  return (__builtin_constant_p((3)) ? constant_test_bit((3), (&q->queue_flags)) : variable_test_bit((3), (&q->queue_flags)));
> return (__builtin_constant_p((4)) ? constant_test_bit((4), (&q->queue_flags)) : variable_test_bit((4), (&q->queue_flags)));
>}
>
>static inline __attribute__((always_inline)) void blk_set_queue_full(struct request_queue *q, int rw)
>{
> if (rw == 0)
>  queue_flag_set(3, q);
> else
>  queue_flag_set(4, q);
>}
>
>static inline __attribute__((always_inline)) void blk_clear_queue_full(struct request_queue *q, int rw)
>{
> if (rw == 0)
>  queue_flag_clear(3, q);
> else
>  queue_flag_clear(4, q);
>}
># 566 "include/linux/blkdev.h"
>extern unsigned long blk_max_low_pfn, blk_max_pfn;
># 593 "include/linux/blkdev.h"
>static inline __attribute__((always_inline)) int init_emergency_isa_pool(void)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) void blk_queue_bounce(struct request_queue *q, struct bio **bio)
>{
>}
>
>
>struct req_iterator {
> int i;
> struct bio *bio;
>};
># 619 "include/linux/blkdev.h"
>extern int blk_register_queue(struct gendisk *disk);
>extern void blk_unregister_queue(struct gendisk *disk);
>extern void register_disk(struct gendisk *dev);
>extern void generic_make_request(struct bio *bio);
>extern void blk_rq_init(struct request_queue *q, struct request *rq);
>extern void blk_put_request(struct request *);
>extern void __blk_put_request(struct request_queue *, struct request *);
>extern void blk_end_sync_rq(struct request *rq, int error);
>extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
>extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
>extern void blk_requeue_request(struct request_queue *, struct request *);
>extern void blk_plug_device(struct request_queue *);
>extern int blk_remove_plug(struct request_queue *);
>extern void blk_recount_segments(struct request_queue *, struct bio *);
>extern int scsi_cmd_ioctl(struct file *, struct request_queue *,
>     struct gendisk *, unsigned int, void *);
>extern int sg_scsi_ioctl(struct file *, struct request_queue *,
>  struct gendisk *, struct scsi_ioctl_command *);
>
>
>
>
>extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
>        struct bio *bio);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void blk_clear_queue_congested(struct request_queue *q, int rw)
>{
> clear_bdi_congested(&q->backing_dev_info, rw);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void blk_set_queue_congested(struct request_queue *q, int rw)
>{
> set_bdi_congested(&q->backing_dev_info, rw);
>}
>
>extern void blk_start_queue(struct request_queue *q);
>extern void blk_stop_queue(struct request_queue *q);
>extern void blk_sync_queue(struct request_queue *q);
>extern void __blk_stop_queue(struct request_queue *q);
>extern void __blk_run_queue(struct request_queue *);
>extern void blk_run_queue(struct request_queue *);
>extern void blk_start_queueing(struct request_queue *);
>extern int blk_rq_map_user(struct request_queue *, struct request *, void *, unsigned long);
>extern int blk_rq_unmap_user(struct bio *);
>extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
>extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
>          struct sg_iovec *, int, unsigned int);
>extern int blk_execute_rq(struct request_queue *, struct gendisk *,
>     struct request *, int);
>extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
>      struct request *, int, rq_end_io_fn *);
>extern int blk_verify_command(unsigned char *, int);
>extern void blk_unplug(struct request_queue *q);
>
>static inline __attribute__((always_inline)) struct request_queue *bdev_get_queue(struct block_device *bdev)
>{
> return bdev->bd_disk->queue;
>}
>
>static inline __attribute__((always_inline)) void blk_run_backing_dev(struct backing_dev_info *bdi,
>           struct page *page)
>{
> if (bdi && bdi->unplug_io_fn)
>  bdi->unplug_io_fn(bdi, page);
>}
>
>static inline __attribute__((always_inline)) void blk_run_address_space(struct address_space *mapping)
>{
> if (mapping)
>  blk_run_backing_dev(mapping->backing_dev_info, ((void *)0));
>}
># 709 "include/linux/blkdev.h"
>extern int blk_end_request(struct request *rq, int error,
>    unsigned int nr_bytes);
>extern int __blk_end_request(struct request *rq, int error,
>    unsigned int nr_bytes);
>extern int blk_end_bidi_request(struct request *rq, int error,
>    unsigned int nr_bytes, unsigned int bidi_bytes);
>extern void end_request(struct request *, int);
>extern void end_queued_request(struct request *, int);
>extern void end_dequeued_request(struct request *, int);
>extern int blk_end_request_callback(struct request *rq, int error,
>    unsigned int nr_bytes,
>    int (drv_callback)(struct request *));
>extern void blk_complete_request(struct request *);
>
>
>
>
>
>
>extern unsigned int blk_rq_bytes(struct request *rq);
>extern unsigned int blk_rq_cur_bytes(struct request *rq);
>
>static inline __attribute__((always_inline)) void blkdev_dequeue_request(struct request *req)
>{
> elv_dequeue_request(req->q, req);
>}
>
>
>
>
>extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
>     spinlock_t *lock, int node_id);
>extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
>extern void blk_cleanup_queue(struct request_queue *);
>extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
>extern void blk_queue_bounce_limit(struct request_queue *, u64);
>extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
>extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
>extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
>extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
>extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
>extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
>extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
>extern int blk_queue_dma_drain(struct request_queue *q,
>          dma_drain_needed_fn *dma_drain_needed,
>          void *buf, unsigned int size);
>extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
>extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
>extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
>extern void blk_queue_dma_alignment(struct request_queue *, int);
>extern void blk_queue_update_dma_alignment(struct request_queue *, int);
>extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
>extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
>extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
>extern int blk_do_ordered(struct request_queue *, struct request **);
>extern unsigned blk_ordered_cur_seq(struct request_queue *);
>extern unsigned blk_ordered_req_seq(struct request *);
>extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int);
>
>extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
>extern void blk_dump_rq_flags(struct request *, char *);
>extern void generic_unplug_device(struct request_queue *);
>extern void __generic_unplug_device(struct request_queue *);
>extern long nr_blockdev_pages(void);
>
>int blk_get_queue(struct request_queue *);
>struct request_queue *blk_alloc_queue(gfp_t);
>struct request_queue *blk_alloc_queue_node(gfp_t, int);
>extern void blk_put_queue(struct request_queue *);
>
>
>
>
>
>
>
>extern int blk_queue_start_tag(struct request_queue *, struct request *);
>extern struct request *blk_queue_find_tag(struct request_queue *, int);
>extern void blk_queue_end_tag(struct request_queue *, struct request *);
>extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
>extern void blk_queue_free_tags(struct request_queue *);
>extern int blk_queue_resize_tags(struct request_queue *, int);
>extern void blk_queue_invalidate_tags(struct request_queue *);
>extern struct blk_queue_tag *blk_init_tags(int);
>extern void blk_free_tags(struct blk_queue_tag *);
>
>static inline __attribute__((always_inline)) struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
>      int tag)
>{
> if (__builtin_expect(!!(bqt == ((void *)0) || tag >= bqt->real_max_depth), 0))
>  return ((void *)0);
> return bqt->tag_index[tag];
>}
>
>extern int blkdev_issue_flush(struct block_device *, sector_t *);
># 814 "include/linux/blkdev.h"
>static inline __attribute__((always_inline)) int queue_hardsect_size(struct request_queue *q)
>{
> int retval = 512;
>
> if (q && q->hardsect_size)
>  retval = q->hardsect_size;
>
> return retval;
>}
>
>static inline __attribute__((always_inline)) int bdev_hardsect_size(struct block_device *bdev)
>{
> return queue_hardsect_size(bdev_get_queue(bdev));
>}
>
>static inline __attribute__((always_inline)) int queue_dma_alignment(struct request_queue *q)
>{
> return q ? q->dma_alignment : 511;
>}
>
>
>static inline __attribute__((always_inline)) unsigned int blksize_bits(unsigned int size)
>{
> unsigned int bits = 8;
> do {
>  bits++;
>  size >>= 1;
> } while (size > 256);
> return bits;
>}
>
>static inline __attribute__((always_inline)) unsigned int block_size(struct block_device *bdev)
>{
> return bdev->bd_block_size;
>}
>
>typedef struct {struct page *v;} Sector;
>
>unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
>
>static inline __attribute__((always_inline)) void put_dev_sector(Sector p)
>{
> put_page(p.v);
>}
>
>struct work_struct;
>int kblockd_schedule_work(struct work_struct *work);
>void kblockd_flush_work(struct work_struct *work);
># 48 "kernel/sched.c" 2
>
># 1 "include/linux/delay.h" 1
># 12 "include/linux/delay.h"
>extern unsigned long loops_per_jiffy;
>
>
># 1 "include/asm/delay.h" 1
>
>
>
>
>
>
>extern void __bad_udelay(void);
>
>extern void __udelay(unsigned long usecs);
>extern void __delay(unsigned long loops);
>
>
>
>
>
>
>extern void __unimplemented_ndelay(void);
># 15 "include/linux/delay.h" 2
># 44 "include/linux/delay.h"
>void calibrate_delay(void);
>void msleep(unsigned int msecs);
>unsigned long msleep_interruptible(unsigned int msecs);
>
>static inline __attribute__((always_inline)) void ssleep(unsigned int seconds)
>{
> msleep(seconds * 1000);
>}
># 49 "kernel/sched.c" 2
>
># 1 "include/linux/pid_namespace.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/nsproxy.h" 1
>
>
>
>
>
>
>struct mnt_namespace;
>struct uts_namespace;
>struct ipc_namespace;
>struct pid_namespace;
># 24 "include/linux/nsproxy.h"
>struct nsproxy {
> atomic_t count;
> struct uts_namespace *uts_ns;
> struct ipc_namespace *ipc_ns;
> struct mnt_namespace *mnt_ns;
> struct pid_namespace *pid_ns;
> struct user_namespace *user_ns;
> struct net *net_ns;
>};
>extern struct nsproxy init_nsproxy;
># 60 "include/linux/nsproxy.h"
>static inline __attribute__((always_inline)) struct nsproxy *task_nsproxy(struct task_struct *tsk)
>{
> return ({ typeof(tsk->nsproxy) _________p1 = (*(volatile typeof(tsk->nsproxy) *)&(tsk->nsproxy)); do { } while (0); (_________p1); });
>}
>
>int copy_namespaces(unsigned long flags, struct task_struct *tsk);
>void exit_task_namespaces(struct task_struct *tsk);
>void switch_task_namespaces(struct task_struct *tsk, struct nsproxy *new);
>void free_nsproxy(struct nsproxy *ns);
>int unshare_nsproxy_namespaces(unsigned long, struct nsproxy **,
> struct fs_struct *);
>
>static inline __attribute__((always_inline)) void put_nsproxy(struct nsproxy *ns)
>{
> if (atomic_dec_and_test(&ns->count)) {
>  free_nsproxy(ns);
> }
>}
>
>static inline __attribute__((always_inline)) void get_nsproxy(struct nsproxy *ns)
>{
> atomic_inc(&ns->count);
>}
>
>
>
>
>static inline __attribute__((always_inline)) int ns_cgroup_clone(struct task_struct *tsk) { return 0; }
># 8 "include/linux/pid_namespace.h" 2
>
>
>struct pidmap {
>       atomic_t nr_free;
>       void *page;
>};
>
>
>
>struct pid_namespace {
> struct kref kref;
> struct pidmap pidmap[(((0 ? ((1UL) << 12) * 8 : (sizeof(long) > 4 ? 4 * 1024 * 1024 : (0 ? 0x1000 : 0x8000))) + 8*((1UL) << 12) - 1)/((1UL) << 12)/8)];
> int last_pid;
> struct task_struct *child_reaper;
> struct kmem_cache *pid_cachep;
> unsigned int level;
> struct pid_namespace *parent;
>
> struct vfsmount *proc_mnt;
>
>};
>
>extern struct pid_namespace init_pid_ns;
># 53 "include/linux/pid_namespace.h"
>static inline __attribute__((always_inline)) struct pid_namespace *get_pid_ns(struct pid_namespace *ns)
>{
> return ns;
>}
>
>static inline __attribute__((always_inline)) struct pid_namespace *
>copy_pid_ns(unsigned long flags, struct pid_namespace *ns)
>{
> if (flags & 0x20000000)
>  ns = ERR_PTR(-22);
> return ns;
>}
>
>static inline __attribute__((always_inline)) void put_pid_ns(struct pid_namespace *ns)
>{
>}
>
>
>static inline __attribute__((always_inline)) void zap_pid_ns_processes(struct pid_namespace *ns)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/pid_namespace.h", 73, (__func__)); panic("BUG!"); } while (0);
>}
>
>
>static inline __attribute__((always_inline)) struct pid_namespace *task_active_pid_ns(struct task_struct *tsk)
>{
> return tsk->nsproxy->pid_ns;
>}
>
>static inline __attribute__((always_inline)) struct task_struct *task_child_reaper(struct task_struct *tsk)
>{
> do { if (__builtin_expect(!!(tsk != (current_thread_info()->task)), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/pid_namespace.h", 84, (__func__)); panic("BUG!"); } while (0); } while(0);
> return tsk->nsproxy->pid_ns->child_reaper;
>}
># 50 "kernel/sched.c" 2
>
>
>
>
>
># 1 "include/linux/cpu.h" 1
># 22 "include/linux/cpu.h"
>
># 1 "include/linux/sysdev.h" 1
># 29 "include/linux/sysdev.h"
>struct sys_device;
>
>struct sysdev_class {
> const char *name;
> 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);
>};
># 60 "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);
>};
># 118 "include/linux/sysdev.h"
>extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
>extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
># 23 "include/linux/cpu.h" 2
>
># 1 "include/linux/node.h" 1
># 25 "include/linux/node.h"
>struct node {
> struct sys_device sysdev;
>};
>
>extern struct node node_devices[];
>
>extern int register_node(struct node *, int, struct node *);
>extern void unregister_node(struct node *node);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int register_one_node(int nid)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int unregister_one_node(int nid)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int register_cpu_under_node(unsigned int cpu, unsigned int nid)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
>{
> return 0;
>}
># 24 "include/linux/cpu.h" 2
>
>
>
>
>struct cpu {
> int node_id;
> int hotpluggable;
> struct sys_device sysdev;
>};
>
>extern int register_cpu(struct cpu *cpu, int num);
>extern struct sys_device *get_cpu_sysdev(unsigned cpu);
>
>extern int cpu_add_sysdev_attr(struct sysdev_attribute *attr);
>extern void cpu_remove_sysdev_attr(struct sysdev_attribute *attr);
>
>extern int cpu_add_sysdev_attr_group(struct attribute_group *attrs);
>extern void cpu_remove_sysdev_attr_group(struct attribute_group *attrs);
>
>extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls);
>
>
>
>
>struct notifier_block;
># 77 "include/linux/cpu.h"
>static inline __attribute__((always_inline)) int register_cpu_notifier(struct notifier_block *nb)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void unregister_cpu_notifier(struct notifier_block *nb)
>{
>}
>
>static inline __attribute__((always_inline)) void cpu_hotplug_init(void)
>{
>}
>
>
>extern struct sysdev_class cpu_sysdev_class;
>extern void cpu_maps_update_begin(void);
>extern void cpu_maps_update_done(void);
># 121 "include/linux/cpu.h"
>static inline __attribute__((always_inline)) void cpuhotplug_mutex_lock(struct mutex *cpu_hp_mutex)
>{ }
>static inline __attribute__((always_inline)) void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
>{ }
># 142 "include/linux/cpu.h"
>static inline __attribute__((always_inline)) int disable_nonboot_cpus(void) { return 0; }
>static inline __attribute__((always_inline)) void enable_nonboot_cpus(void) {}
># 55 "kernel/sched.c" 2
>
># 1 "include/linux/cpuset.h" 1
># 14 "include/linux/cpuset.h"
>
># 1 "include/linux/cgroup.h" 1
># 16 "include/linux/cgroup.h"
>
># 1 "include/linux/cgroupstats.h" 1
># 18 "include/linux/cgroupstats.h"
>
># 1 "include/linux/taskstats.h" 1
># 38 "include/linux/taskstats.h"
>struct taskstats {
>
>
>
>
>
> __u16 version;
> __u32 ac_exitcode;
>
>
>
>
> __u8 ac_flag;
> __u8 ac_nice;
># 69 "include/linux/taskstats.h"
> __u64 cpu_count __attribute__((aligned(8)));
> __u64 cpu_delay_total;
>
>
>
>
>
>
> __u64 blkio_count;
> __u64 blkio_delay_total;
>
>
> __u64 swapin_count;
> __u64 swapin_delay_total;
>
>
>
>
>
>
>
> __u64 cpu_run_real_total;
>
>
>
>
>
>
>
> __u64 cpu_run_virtual_total;
>
>
>
>
> char ac_comm[32];
> __u8 ac_sched __attribute__((aligned(8)));
>
> __u8 ac_pad[3];
> __u32 ac_uid __attribute__((aligned(8)));
>
> __u32 ac_gid;
> __u32 ac_pid;
> __u32 ac_ppid;
> __u32 ac_btime;
> __u64 ac_etime __attribute__((aligned(8)));
>
> __u64 ac_utime;
> __u64 ac_stime;
> __u64 ac_minflt;
> __u64 ac_majflt;
># 128 "include/linux/taskstats.h"
> __u64 coremem;
>
>
>
> __u64 virtmem;
>
>
>
>
> __u64 hiwater_rss;
> __u64 hiwater_vm;
>
>
> __u64 read_char;
> __u64 write_char;
> __u64 read_syscalls;
> __u64 write_syscalls;
>
>
>
>
> __u64 read_bytes;
> __u64 write_bytes;
> __u64 cancelled_write_bytes;
>
> __u64 nvcsw;
> __u64 nivcsw;
>
>
> __u64 ac_utimescaled;
> __u64 ac_stimescaled;
> __u64 cpu_scaled_run_real_total;
>};
># 169 "include/linux/taskstats.h"
>enum {
> TASKSTATS_CMD_UNSPEC = 0,
> TASKSTATS_CMD_GET,
> TASKSTATS_CMD_NEW,
> __TASKSTATS_CMD_MAX,
>};
>
>
>
>enum {
> TASKSTATS_TYPE_UNSPEC = 0,
> TASKSTATS_TYPE_PID,
> TASKSTATS_TYPE_TGID,
> TASKSTATS_TYPE_STATS,
> TASKSTATS_TYPE_AGGR_PID,
> TASKSTATS_TYPE_AGGR_TGID,
> __TASKSTATS_TYPE_MAX,
>};
>
>
>
>enum {
> TASKSTATS_CMD_ATTR_UNSPEC = 0,
> TASKSTATS_CMD_ATTR_PID,
> TASKSTATS_CMD_ATTR_TGID,
> TASKSTATS_CMD_ATTR_REGISTER_CPUMASK,
> TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK,
> __TASKSTATS_CMD_ATTR_MAX,
>};
># 19 "include/linux/cgroupstats.h" 2
># 30 "include/linux/cgroupstats.h"
>struct cgroupstats {
> __u64 nr_sleeping;
> __u64 nr_running;
> __u64 nr_stopped;
> __u64 nr_uninterruptible;
>
> __u64 nr_io_wait;
>};
>
>
>
>
>
>
>
>enum {
> CGROUPSTATS_CMD_UNSPEC = __TASKSTATS_CMD_MAX,
> CGROUPSTATS_CMD_GET,
> CGROUPSTATS_CMD_NEW,
> __CGROUPSTATS_CMD_MAX,
>};
>
>
>
>enum {
> CGROUPSTATS_TYPE_UNSPEC = 0,
> CGROUPSTATS_TYPE_CGROUP_STATS,
> __CGROUPSTATS_TYPE_MAX,
>};
>
>
>
>enum {
> CGROUPSTATS_CMD_ATTR_UNSPEC = 0,
> CGROUPSTATS_CMD_ATTR_FD,
> __CGROUPSTATS_CMD_ATTR_MAX,
>};
># 17 "include/linux/cgroup.h" 2
>
># 1 "include/linux/prio_heap.h" 1
># 18 "include/linux/prio_heap.h"
>struct ptr_heap {
> void **ptrs;
> int max;
> int size;
> int (*gt)(void *, void *);
>};
># 32 "include/linux/prio_heap.h"
>extern int heap_init(struct ptr_heap *heap, size_t size, gfp_t gfp_mask,
>       int (*gt)(void *, void *));
>
>
>
>
>
>void heap_free(struct ptr_heap *heap);
># 54 "include/linux/prio_heap.h"
>extern void *heap_insert(struct ptr_heap *heap, void *p);
># 18 "include/linux/cgroup.h" 2
># 381 "include/linux/cgroup.h"
>static inline __attribute__((always_inline)) int cgroup_init_early(void) { return 0; }
>static inline __attribute__((always_inline)) int cgroup_init(void) { return 0; }
>static inline __attribute__((always_inline)) void cgroup_init_smp(void) {}
>static inline __attribute__((always_inline)) void cgroup_fork(struct task_struct *p) {}
>static inline __attribute__((always_inline)) void cgroup_fork_callbacks(struct task_struct *p) {}
>static inline __attribute__((always_inline)) void cgroup_post_fork(struct task_struct *p) {}
>static inline __attribute__((always_inline)) void cgroup_exit(struct task_struct *p, int callbacks) {}
>
>static inline __attribute__((always_inline)) void cgroup_lock(void) {}
>static inline __attribute__((always_inline)) void cgroup_unlock(void) {}
>static inline __attribute__((always_inline)) int cgroupstats_build(struct cgroupstats *stats,
>     struct dentry *dentry)
>{
> return -22;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new)
>{
>}
># 15 "include/linux/cpuset.h" 2
># 83 "include/linux/cpuset.h"
>static inline __attribute__((always_inline)) int cpuset_init_early(void) { return 0; }
>static inline __attribute__((always_inline)) int cpuset_init(void) { return 0; }
>static inline __attribute__((always_inline)) void cpuset_init_smp(void) {}
>
>static inline __attribute__((always_inline)) void cpuset_cpus_allowed(struct task_struct *p, cpumask_t *mask)
>{
> *mask = cpu_possible_map;
>}
>static inline __attribute__((always_inline)) void cpuset_cpus_allowed_locked(struct task_struct *p,
>        cpumask_t *mask)
>{
> *mask = cpu_possible_map;
>}
>
>static inline __attribute__((always_inline)) nodemask_t cpuset_mems_allowed(struct task_struct *p)
>{
> return node_states[N_POSSIBLE];
>}
>
>
>static inline __attribute__((always_inline)) void cpuset_init_current_mems_allowed(void) {}
>static inline __attribute__((always_inline)) void cpuset_update_task_memory_state(void) {}
>
>static inline __attribute__((always_inline)) int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) int cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) int cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) int cpuset_mems_allowed_intersects(const struct task_struct *tsk1,
>       const struct task_struct *tsk2)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) void cpuset_memory_pressure_bump(void) {}
>
>static inline __attribute__((always_inline)) void cpuset_task_status_allowed(struct seq_file *m,
>      struct task_struct *task)
>{
>}
>
>static inline __attribute__((always_inline)) void cpuset_lock(void) {}
>static inline __attribute__((always_inline)) void cpuset_unlock(void) {}
>
>static inline __attribute__((always_inline)) int cpuset_mem_spread_node(void)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int cpuset_do_page_mem_spread(void)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int cpuset_do_slab_mem_spread(void)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void cpuset_track_online_nodes(void) {}
>
>static inline __attribute__((always_inline)) int current_cpuset_is_being_rebound(void)
>{
> return 0;
>}
># 56 "kernel/sched.c" 2
>
>
># 1 "include/linux/kthread.h" 1
>
>
>
>
>
>
>struct task_struct *kthread_create(int (*threadfn)(void *data),
>       void *data,
>       const char namefmt[], ...);
># 29 "include/linux/kthread.h"
>void kthread_bind(struct task_struct *k, unsigned int cpu);
>int kthread_stop(struct task_struct *k);
>int kthread_should_stop(void);
>
>int kthreadd(void *unused);
>extern struct task_struct *kthreadd_task;
># 58 "kernel/sched.c" 2
>
># 1 "include/linux/seq_file.h" 1
>
>
>
>
>
>
>
>struct seq_operations;
>struct file;
>struct path;
>struct inode;
>struct dentry;
>
>struct seq_file {
> char *buf;
> size_t size;
> size_t from;
> size_t count;
> loff_t index;
> u64 version;
> struct mutex lock;
> const 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 *, const 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 path *, char *);
>int seq_dentry(struct seq_file *, struct dentry *, char *);
>int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
>    char *esc);
>
>int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
>int single_release(struct inode *, struct file *);
>void *__seq_open_private(struct file *, const struct seq_operations *, int);
>int seq_open_private(struct file *, const struct seq_operations *, int);
>int seq_release_private(struct inode *, struct file *);
>
>
>
>
>
>
>
>extern struct list_head *seq_list_start(struct list_head *head,
>  loff_t pos);
>extern struct list_head *seq_list_start_head(struct list_head *head,
>  loff_t pos);
>extern struct list_head *seq_list_next(void *v, struct list_head *head,
>  loff_t *ppos);
># 59 "kernel/sched.c" 2
>
>
># 1 "include/linux/syscalls.h" 1
># 14 "include/linux/syscalls.h"
>struct epoll_event;
>struct iattr;
>struct inode;
>struct iocb;
>struct io_event;
>struct iovec;
>struct itimerspec;
>struct itimerval;
>struct kexec_segment;
>struct linux_dirent;
>struct linux_dirent64;
>struct list_head;
>struct msgbuf;
>struct msghdr;
>struct msqid_ds;
>struct new_utsname;
>struct nfsctl_arg;
>struct __old_kernel_stat;
>struct pollfd;
>struct rlimit;
>struct rusage;
>struct sched_param;
>struct semaphore;
>struct sembuf;
>struct shmid_ds;
>struct sockaddr;
>struct stat;
>struct stat64;
>struct statfs;
>struct statfs64;
>struct __sysctl_args;
>struct sysinfo;
>struct timespec;
>struct timeval;
>struct timex;
>struct timezone;
>struct tms;
>struct utimbuf;
>struct mq_attr;
>struct compat_stat;
>struct compat_timeval;
>struct robust_list_head;
>struct getcpu_cache;
># 68 "include/linux/syscalls.h"
> long sys_time(time_t *tloc);
> long sys_stime(time_t *tptr);
> long sys_gettimeofday(struct timeval *tv,
>    struct timezone *tz);
> long sys_settimeofday(struct timeval *tv,
>    struct timezone *tz);
> long sys_adjtimex(struct timex *txc_p);
>
> long sys_times(struct tms *tbuf);
>
> long sys_gettid(void);
> long sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp);
> unsigned long sys_alarm(unsigned int seconds);
> long sys_getpid(void);
> long sys_getppid(void);
> long sys_getuid(void);
> long sys_geteuid(void);
> long sys_getgid(void);
> long sys_getegid(void);
> long sys_getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
> long sys_getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
> long sys_getpgid(pid_t pid);
> long sys_getpgrp(void);
> long sys_getsid(pid_t pid);
> long sys_getgroups(int gidsetsize, gid_t *grouplist);
>
> long sys_setregid(gid_t rgid, gid_t egid);
> long sys_setgid(gid_t gid);
> long sys_setreuid(uid_t ruid, uid_t euid);
> long sys_setuid(uid_t uid);
> long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid);
> long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid);
> long sys_setfsuid(uid_t uid);
> long sys_setfsgid(gid_t gid);
> long sys_setpgid(pid_t pid, pid_t pgid);
> long sys_setsid(void);
> long sys_setgroups(int gidsetsize, gid_t *grouplist);
>
> long sys_acct(const char *name);
> long sys_capget(cap_user_header_t header,
>    cap_user_data_t dataptr);
> long sys_capset(cap_user_header_t header,
>    const cap_user_data_t data);
> long sys_personality(u_long personality);
>
> long sys_sigpending(old_sigset_t *set);
> long sys_sigprocmask(int how, old_sigset_t *set,
>    old_sigset_t *oset);
> long sys_getitimer(int which, struct itimerval *value);
> long sys_setitimer(int which,
>    struct itimerval *value,
>    struct itimerval *ovalue);
> long sys_timer_create(clockid_t which_clock,
>     struct sigevent *timer_event_spec,
>     timer_t * created_timer_id);
> long sys_timer_gettime(timer_t timer_id,
>    struct itimerspec *setting);
> long sys_timer_getoverrun(timer_t timer_id);
> long sys_timer_settime(timer_t timer_id, int flags,
>    const struct itimerspec *new_setting,
>    struct itimerspec *old_setting);
> long sys_timer_delete(timer_t timer_id);
> long sys_clock_settime(clockid_t which_clock,
>    const struct timespec *tp);
> long sys_clock_gettime(clockid_t which_clock,
>    struct timespec *tp);
> long sys_clock_getres(clockid_t which_clock,
>    struct timespec *tp);
> long sys_clock_nanosleep(clockid_t which_clock, int flags,
>    const struct timespec *rqtp,
>    struct timespec *rmtp);
>
> long sys_nice(int increment);
> long sys_sched_setscheduler(pid_t pid, int policy,
>     struct sched_param *param);
> long sys_sched_setparam(pid_t pid,
>     struct sched_param *param);
> long sys_sched_getscheduler(pid_t pid);
> long sys_sched_getparam(pid_t pid,
>     struct sched_param *param);
> long sys_sched_setaffinity(pid_t pid, unsigned int len,
>     unsigned long *user_mask_ptr);
> long sys_sched_getaffinity(pid_t pid, unsigned int len,
>     unsigned long *user_mask_ptr);
> long sys_sched_yield(void);
> long sys_sched_get_priority_max(int policy);
> long sys_sched_get_priority_min(int policy);
> long sys_sched_rr_get_interval(pid_t pid,
>     struct timespec *interval);
> long sys_setpriority(int which, int who, int niceval);
> long sys_getpriority(int which, int who);
>
> long sys_shutdown(int, int);
> long sys_reboot(int magic1, int magic2, unsigned int cmd,
>    void *arg);
> long sys_restart_syscall(void);
> long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
>    struct kexec_segment *segments,
>    unsigned long flags);
>
> long sys_exit(int error_code);
> void sys_exit_group(int error_code);
> long sys_wait4(pid_t pid, int *stat_addr,
>    int options, struct rusage *ru);
> long sys_waitid(int which, pid_t pid,
>      struct siginfo *infop,
>      int options, struct rusage *ru);
> long sys_waitpid(pid_t pid, int *stat_addr, int options);
> long sys_set_tid_address(int *tidptr);
> long sys_futex(u32 *uaddr, int op, u32 val,
>   struct timespec *utime, u32 *uaddr2,
>   u32 val3);
>
> long sys_init_module(void *umod, unsigned long len,
>    const char *uargs);
> long sys_delete_module(const char *name_user,
>    unsigned int flags);
>
> long sys_rt_sigprocmask(int how, sigset_t *set,
>    sigset_t *oset, size_t sigsetsize);
> long sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
> long sys_rt_sigtimedwait(const sigset_t *uthese,
>    siginfo_t *uinfo,
>    const struct timespec *uts,
>    size_t sigsetsize);
> long sys_kill(int pid, int sig);
> long sys_tgkill(int tgid, int pid, int sig);
> long sys_tkill(int pid, int sig);
> long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
> long sys_sgetmask(void);
> long sys_ssetmask(int newmask);
> unsigned long sys_signal(int sig, __sighandler_t handler);
> long sys_pause(void);
>
> long sys_sync(void);
> long sys_fsync(unsigned int fd);
> long sys_fdatasync(unsigned int fd);
> long sys_bdflush(int func, long data);
> long sys_mount(char *dev_name, char *dir_name,
>    char *type, unsigned long flags,
>    void *data);
> long sys_umount(char *name, int flags);
> long sys_oldumount(char *name);
> long sys_truncate(const char *path,
>    unsigned long length);
> long sys_ftruncate(unsigned int fd, unsigned long length);
> long sys_stat(char *filename,
>   struct __old_kernel_stat *statbuf);
> long sys_statfs(const char * path,
>    struct statfs *buf);
> long sys_statfs64(const char *path, size_t sz,
>    struct statfs64 *buf);
> long sys_fstatfs(unsigned int fd, struct statfs *buf);
> long sys_fstatfs64(unsigned int fd, size_t sz,
>    struct statfs64 *buf);
> long sys_lstat(char *filename,
>   struct __old_kernel_stat *statbuf);
> long sys_fstat(unsigned int fd,
>   struct __old_kernel_stat *statbuf);
> long sys_newstat(char *filename,
>    struct stat *statbuf);
> long sys_newlstat(char *filename,
>    struct stat *statbuf);
> long sys_newfstat(unsigned int fd, struct stat *statbuf);
> long sys_ustat(unsigned dev, struct ustat *ubuf);
># 243 "include/linux/syscalls.h"
> long sys_setxattr(const char *path, const char *name,
>        const void *value, size_t size, int flags);
> long sys_lsetxattr(const char *path, const char *name,
>         const void *value, size_t size, int flags);
> long sys_fsetxattr(int fd, const char *name,
>         const void *value, size_t size, int flags);
> ssize_t sys_getxattr(const char *path, const char *name,
>    void *value, size_t size);
> ssize_t sys_lgetxattr(const char *path, const char *name,
>    void *value, size_t size);
> ssize_t sys_fgetxattr(int fd, const char *name,
>    void *value, size_t size);
> ssize_t sys_listxattr(const char *path, char *list,
>    size_t size);
> ssize_t sys_llistxattr(const char *path, char *list,
>    size_t size);
> ssize_t sys_flistxattr(int fd, char *list, size_t size);
> long sys_removexattr(const char *path,
>    const char *name);
> long sys_lremovexattr(const char *path,
>     const char *name);
> long sys_fremovexattr(int fd, const char *name);
>
> unsigned long sys_brk(unsigned long brk);
> long sys_mprotect(unsigned long start, size_t len,
>    unsigned long prot);
> unsigned long sys_mremap(unsigned long addr,
>    unsigned long old_len, unsigned long new_len,
>    unsigned long flags, unsigned long new_addr);
> long sys_remap_file_pages(unsigned long start, unsigned long size,
>   unsigned long prot, unsigned long pgoff,
>   unsigned long flags);
> long sys_msync(unsigned long start, size_t len, int flags);
> long sys_fadvise64(int fd, loff_t offset, size_t len, int advice);
> long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice);
> long sys_munmap(unsigned long addr, size_t len);
> long sys_mlock(unsigned long start, size_t len);
> long sys_munlock(unsigned long start, size_t len);
> long sys_mlockall(int flags);
> long sys_munlockall(void);
> long sys_madvise(unsigned long start, size_t len, int behavior);
> long sys_mincore(unsigned long start, size_t len,
>    unsigned char * vec);
>
> long sys_pivot_root(const char *new_root,
>    const char *put_old);
> long sys_chroot(const char *filename);
> long sys_mknod(const char *filename, int mode,
>    unsigned dev);
> long sys_link(const char *oldname,
>    const char *newname);
> long sys_symlink(const char *old, const char *new);
> long sys_unlink(const char *pathname);
> long sys_rename(const char *oldname,
>    const char *newname);
> long sys_chmod(const char *filename, mode_t mode);
> long sys_fchmod(unsigned int fd, mode_t mode);
>
> long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
>
>
>
>
> long sys_dup(unsigned int fildes);
> long sys_dup2(unsigned int oldfd, unsigned int newfd);
> long sys_ioperm(unsigned long from, unsigned long num, int on);
> long sys_ioctl(unsigned int fd, unsigned int cmd,
>    unsigned long arg);
> long sys_flock(unsigned int fd, unsigned int cmd);
> long sys_io_setup(unsigned nr_reqs, aio_context_t *ctx);
> long sys_io_destroy(aio_context_t ctx);
> long sys_io_getevents(aio_context_t ctx_id,
>    long min_nr,
>    long nr,
>    struct io_event *events,
>    struct timespec *timeout);
> long sys_io_submit(aio_context_t, long,
>    struct iocb * *);
> long sys_io_cancel(aio_context_t ctx_id, struct iocb *iocb,
>         struct io_event *result);
> ssize_t sys_sendfile(int out_fd, int in_fd,
>    off_t *offset, size_t count);
> ssize_t sys_sendfile64(int out_fd, int in_fd,
>    loff_t *offset, size_t count);
> long sys_readlink(const char *path,
>    char *buf, int bufsiz);
> long sys_creat(const char *pathname, int mode);
> long sys_open(const char *filename,
>    int flags, int mode);
> long sys_close(unsigned int fd);
> long sys_access(const char *filename, int mode);
> long sys_vhangup(void);
> long sys_chown(const char *filename,
>    uid_t user, gid_t group);
> long sys_lchown(const char *filename,
>    uid_t user, gid_t group);
> long sys_fchown(unsigned int fd, uid_t user, gid_t group);
>
> long sys_chown16(const char *filename,
>    old_uid_t user, old_gid_t group);
> long sys_lchown16(const char *filename,
>    old_uid_t user, old_gid_t group);
> long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group);
> long sys_setregid16(old_gid_t rgid, old_gid_t egid);
> long sys_setgid16(old_gid_t gid);
> long sys_setreuid16(old_uid_t ruid, old_uid_t euid);
> long sys_setuid16(old_uid_t uid);
> long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid);
> long sys_getresuid16(old_uid_t *ruid,
>    old_uid_t *euid, old_uid_t *suid);
> long sys_setresgid16(old_gid_t rgid, old_gid_t egid, old_gid_t sgid);
> long sys_getresgid16(old_gid_t *rgid,
>    old_gid_t *egid, old_gid_t *sgid);
> long sys_setfsuid16(old_uid_t uid);
> long sys_setfsgid16(old_gid_t gid);
> long sys_getgroups16(int gidsetsize, old_gid_t *grouplist);
> long sys_setgroups16(int gidsetsize, old_gid_t *grouplist);
> long sys_getuid16(void);
> long sys_geteuid16(void);
> long sys_getgid16(void);
> long sys_getegid16(void);
>
>
> long sys_utime(char *filename,
>    struct utimbuf *times);
> long sys_utimes(char *filename,
>    struct timeval *utimes);
> off_t sys_lseek(unsigned int fd, off_t offset,
>    unsigned int origin);
> long sys_llseek(unsigned int fd, unsigned long offset_high,
>   unsigned long offset_low, loff_t *result,
>   unsigned int origin);
> ssize_t sys_read(unsigned int fd, char *buf,
>    size_t count);
> ssize_t sys_readahead(int fd, loff_t offset, size_t count);
> ssize_t sys_readv(unsigned long fd,
>    const struct iovec *vec,
>    unsigned long vlen);
> ssize_t sys_write(unsigned int fd, const char *buf,
>    size_t count);
> ssize_t sys_writev(unsigned long fd,
>    const struct iovec *vec,
>    unsigned long vlen);
> ssize_t sys_pread64(unsigned int fd, char *buf,
>    size_t count, loff_t pos);
> ssize_t sys_pwrite64(unsigned int fd, const char *buf,
>    size_t count, loff_t pos);
> long sys_getcwd(char *buf, unsigned long size);
> long sys_mkdir(const char *pathname, int mode);
> long sys_chdir(const char *filename);
> long sys_fchdir(unsigned int fd);
> long sys_rmdir(const char *pathname);
> long sys_lookup_dcookie(u64 cookie64, char *buf, size_t len);
> long sys_quotactl(unsigned int cmd, const char *special,
>    qid_t id, void *addr);
> long sys_getdents(unsigned int fd,
>    struct linux_dirent *dirent,
>    unsigned int count);
> long sys_getdents64(unsigned int fd,
>    struct linux_dirent64 *dirent,
>    unsigned int count);
>
> long sys_setsockopt(int fd, int level, int optname,
>    char *optval, int optlen);
> long sys_getsockopt(int fd, int level, int optname,
>    char *optval, int *optlen);
> long sys_bind(int, struct sockaddr *, int);
> long sys_connect(int, struct sockaddr *, int);
> long sys_accept(int, struct sockaddr *, int *);
> long sys_getsockname(int, struct sockaddr *, int *);
> long sys_getpeername(int, struct sockaddr *, int *);
> long sys_send(int, void *, size_t, unsigned);
> long sys_sendto(int, void *, size_t, unsigned,
>    struct sockaddr *, int);
> long sys_sendmsg(int fd, struct msghdr *msg, unsigned flags);
> long sys_recv(int, void *, size_t, unsigned);
> long sys_recvfrom(int, void *, size_t, unsigned,
>    struct sockaddr *, int *);
> long sys_recvmsg(int fd, struct msghdr *msg, unsigned flags);
> long sys_socket(int, int, int);
> long sys_socketpair(int, int, int, int *);
> long sys_socketcall(int call, unsigned long *args);
> long sys_listen(int, int);
> long sys_poll(struct pollfd *ufds, unsigned int nfds,
>    long timeout);
> long sys_select(int n, fd_set *inp, fd_set *outp,
>   fd_set *exp, struct timeval *tvp);
> long sys_epoll_create(int size);
> long sys_epoll_ctl(int epfd, int op, int fd,
>    struct epoll_event *event);
> long sys_epoll_wait(int epfd, struct epoll_event *events,
>    int maxevents, int timeout);
> long sys_epoll_pwait(int epfd, struct epoll_event *events,
>    int maxevents, int timeout,
>    const sigset_t *sigmask,
>    size_t sigsetsize);
> long sys_gethostname(char *name, int len);
> long sys_sethostname(char *name, int len);
> long sys_setdomainname(char *name, int len);
> long sys_newuname(struct new_utsname *name);
>
> long sys_getrlimit(unsigned int resource,
>    struct rlimit *rlim);
>
> long sys_old_getrlimit(unsigned int resource, struct rlimit *rlim);
>
> long sys_setrlimit(unsigned int resource,
>    struct rlimit *rlim);
> long sys_getrusage(int who, struct rusage *ru);
> long sys_umask(int mask);
>
> long sys_msgget(key_t key, int msgflg);
> long sys_msgsnd(int msqid, struct msgbuf *msgp,
>    size_t msgsz, int msgflg);
> long sys_msgrcv(int msqid, struct msgbuf *msgp,
>    size_t msgsz, long msgtyp, int msgflg);
> long sys_msgctl(int msqid, int cmd, struct msqid_ds *buf);
>
> long sys_semget(key_t key, int nsems, int semflg);
> long sys_semop(int semid, struct sembuf *sops,
>    unsigned nsops);
> long sys_semctl(int semid, int semnum, int cmd, union semun arg);
> long sys_semtimedop(int semid, struct sembuf *sops,
>    unsigned nsops,
>    const struct timespec *timeout);
> long sys_shmat(int shmid, char *shmaddr, int shmflg);
> long sys_shmget(key_t key, size_t size, int flag);
> long sys_shmdt(char *shmaddr);
> long sys_shmctl(int shmid, int cmd, struct shmid_ds *buf);
>
> long sys_mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr);
> long sys_mq_unlink(const char *name);
> long sys_mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
> ssize_t sys_mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout);
> long sys_mq_notify(mqd_t mqdes, const struct sigevent *notification);
> long sys_mq_getsetattr(mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat);
>
> long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn);
> long sys_pciconfig_read(unsigned long bus, unsigned long dfn,
>    unsigned long off, unsigned long len,
>    void *buf);
> long sys_pciconfig_write(unsigned long bus, unsigned long dfn,
>    unsigned long off, unsigned long len,
>    void *buf);
>
> long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
>   unsigned long arg4, unsigned long arg5);
> long sys_swapon(const char *specialfile, int swap_flags);
> long sys_swapoff(const char *specialfile);
> long sys_sysctl(struct __sysctl_args *args);
> long sys_sysinfo(struct sysinfo *info);
> long sys_sysfs(int option,
>    unsigned long arg1, unsigned long arg2);
> long sys_nfsservctl(int cmd,
>    struct nfsctl_arg *arg,
>    void *res);
> long sys_syslog(int type, char *buf, int len);
> long sys_uselib(const char *library);
> long sys_ni_syscall(void);
> long sys_ptrace(long request, long pid, long addr, long data);
>
> long sys_add_key(const char *_type,
>       const char *_description,
>       const void *_payload,
>       size_t plen,
>       key_serial_t destringid);
>
> long sys_request_key(const char *_type,
>    const char *_description,
>    const char *_callout_info,
>    key_serial_t destringid);
>
> long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3,
>      unsigned long arg4, unsigned long arg5);
>
> long sys_ioprio_set(int which, int who, int ioprio);
> long sys_ioprio_get(int which, int who);
> long sys_set_mempolicy(int mode, unsigned long *nmask,
>    unsigned long maxnode);
> long sys_migrate_pages(pid_t pid, unsigned long maxnode,
>    const unsigned long *from,
>    const unsigned long *to);
> long sys_move_pages(pid_t pid, unsigned long nr_pages,
>    const void * *pages,
>    const int *nodes,
>    int *status,
>    int flags);
> long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
>    __u32 *pages,
>    const int *nodes,
>    int *status,
>    int flags);
> long sys_mbind(unsigned long start, unsigned long len,
>    unsigned long mode,
>    unsigned long *nmask,
>    unsigned long maxnode,
>    unsigned flags);
> long sys_get_mempolicy(int *policy,
>    unsigned long *nmask,
>    unsigned long maxnode,
>    unsigned long addr, unsigned long flags);
>
> long sys_inotify_init(void);
> long sys_inotify_add_watch(int fd, const char *path,
>     u32 mask);
> long sys_inotify_rm_watch(int fd, u32 wd);
>
> long sys_spu_run(int fd, __u32 *unpc,
>     __u32 *ustatus);
> long sys_spu_create(const char *name,
>  unsigned int flags, mode_t mode, int fd);
>
> long sys_mknodat(int dfd, const char * filename, int mode,
>       unsigned dev);
> long sys_mkdirat(int dfd, const char * pathname, int mode);
> long sys_unlinkat(int dfd, const char * pathname, int flag);
> long sys_symlinkat(const char * oldname,
>         int newdfd, const char * newname);
> long sys_linkat(int olddfd, const char *oldname,
>      int newdfd, const char *newname, int flags);
> long sys_renameat(int olddfd, const char * oldname,
>        int newdfd, const char * newname);
> long sys_futimesat(int dfd, char *filename,
>         struct timeval *utimes);
> long sys_faccessat(int dfd, const char *filename, int mode);
> long sys_fchmodat(int dfd, const char * filename,
>        mode_t mode);
> long sys_fchownat(int dfd, const char *filename, uid_t user,
>        gid_t group, int flag);
> long sys_openat(int dfd, const char *filename, int flags,
>      int mode);
> long sys_newfstatat(int dfd, char *filename,
>          struct stat *statbuf, int flag);
> long sys_fstatat64(int dfd, char *filename,
>          struct stat64 *statbuf, int flag);
> long sys_readlinkat(int dfd, const char *path, char *buf,
>          int bufsiz);
> long sys_utimensat(int dfd, char *filename,
>    struct timespec *utimes, int flags);
> long compat_sys_futimesat(unsigned int dfd, char *filename,
>         struct compat_timeval *t);
> long compat_sys_newfstatat(unsigned int dfd, char * filename,
>          struct compat_stat *statbuf,
>          int flag);
> long compat_sys_openat(unsigned int dfd, const char *filename,
>       int flags, int mode);
> long sys_unshare(unsigned long unshare_flags);
>
> long sys_splice(int fd_in, loff_t *off_in,
>      int fd_out, loff_t *off_out,
>      size_t len, unsigned int flags);
>
> long sys_vmsplice(int fd, const struct iovec *iov,
>        unsigned long nr_segs, unsigned int flags);
>
> long sys_tee(int fdin, int fdout, size_t len, unsigned int flags);
>
> long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
>     unsigned int flags);
> long sys_sync_file_range2(int fd, unsigned int flags,
>         loff_t offset, loff_t nbytes);
> long sys_get_robust_list(int pid,
>        struct robust_list_head * *head_ptr,
>        size_t *len_ptr);
> long sys_set_robust_list(struct robust_list_head *head,
>        size_t len);
> long sys_getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *cache);
> long sys_signalfd(int ufd, sigset_t *user_mask, size_t sizemask);
> long sys_timerfd_create(int clockid, int flags);
> long sys_timerfd_settime(int ufd, int flags,
>        const struct itimerspec *utmr,
>        struct itimerspec *otmr);
> long sys_timerfd_gettime(int ufd, struct itimerspec *otmr);
> long sys_eventfd(unsigned int count);
> long sys_fallocate(int fd, int mode, loff_t offset, loff_t len);
>
>int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
># 61 "kernel/sched.c" 2
>
># 1 "include/linux/times.h" 1
>
>
>
>
>
>struct tms {
> clock_t tms_utime;
> clock_t tms_stime;
> clock_t tms_cutime;
> clock_t tms_cstime;
>};
># 62 "kernel/sched.c" 2
>
># 1 "include/linux/tsacct_kern.h" 1
># 15 "include/linux/tsacct_kern.h"
>static inline __attribute__((always_inline)) void bacct_add_tsk(struct taskstats *stats, struct task_struct *tsk)
>{}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void xacct_add_tsk(struct taskstats *stats, struct task_struct *p)
>{}
>static inline __attribute__((always_inline)) void acct_update_integrals(struct task_struct *tsk)
>{}
>static inline __attribute__((always_inline)) void acct_clear_integrals(struct task_struct *tsk)
>{}
># 63 "kernel/sched.c" 2
>
># 1 "include/linux/kprobes.h" 1
># 259 "include/linux/kprobes.h"
>struct jprobe;
>struct kretprobe;
>
>static inline __attribute__((always_inline)) struct kprobe *kprobe_running(void)
>{
> return ((void *)0);
>}
>static inline __attribute__((always_inline)) int register_kprobe(struct kprobe *p)
>{
> return -38;
>}
>static inline __attribute__((always_inline)) int register_kprobes(struct kprobe **kps, int num)
>{
> return -38;
>}
>static inline __attribute__((always_inline)) void unregister_kprobe(struct kprobe *p)
>{
>}
>static inline __attribute__((always_inline)) void unregister_kprobes(struct kprobe **kps, int num)
>{
>}
>static inline __attribute__((always_inline)) int register_jprobe(struct jprobe *p)
>{
> return -38;
>}
>static inline __attribute__((always_inline)) int register_jprobes(struct jprobe **jps, int num)
>{
> return -38;
>}
>static inline __attribute__((always_inline)) void unregister_jprobe(struct jprobe *p)
>{
>}
>static inline __attribute__((always_inline)) void unregister_jprobes(struct jprobe **jps, int num)
>{
>}
>static inline __attribute__((always_inline)) void jprobe_return(void)
>{
>}
>static inline __attribute__((always_inline)) int register_kretprobe(struct kretprobe *rp)
>{
> return -38;
>}
>static inline __attribute__((always_inline)) int register_kretprobes(struct kretprobe **rps, int num)
>{
> return -38;
>}
>static inline __attribute__((always_inline)) void unregister_kretprobe(struct kretprobe *rp)
>{
>}
>static inline __attribute__((always_inline)) void unregister_kretprobes(struct kretprobe **rps, int num)
>{
>}
>static inline __attribute__((always_inline)) void kprobe_flush_task(struct task_struct *tk)
>{
>}
># 64 "kernel/sched.c" 2
>
># 1 "include/linux/delayacct.h" 1
># 21 "include/linux/delayacct.h"
>
># 1 "include/linux/taskstats_kern.h" 1
># 12 "include/linux/taskstats_kern.h"
>
># 1 "include/net/genetlink.h" 1
>
>
>
>
># 1 "include/linux/genetlink.h" 1
>
>
>
>
># 1 "include/linux/netlink.h" 1
>
>
>
>
># 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/arch/socket.h" 1
>
>
>
>
># 1 "include/asm/sockios.h" 1
>
>
>
>
># 1 "include/asm/arch/sockios.h" 1
># 5 "include/asm/sockios.h" 2
># 5 "include/asm/arch/socket.h" 2
># 5 "include/asm/socket.h" 2
># 22 "include/linux/socket.h" 2
>
># 1 "include/linux/sockios.h" 1
># 23 "include/linux/socket.h" 2
>
>
>
>
>
>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;
>};
># 56 "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;
>};
># 129 "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;
>};
># 301 "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, __wsum *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);
># 5 "include/linux/netlink.h" 2
># 30 "include/linux/netlink.h"
>struct net;
>
>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;
>};
># 97 "include/linux/netlink.h"
>struct nlmsgerr
>{
> int error;
> struct nlmsghdr msg;
>};
>
>
>
>
>
>struct nl_pktinfo
>{
> __u32 group;
>};
>
>
>
>enum {
> NETLINK_UNCONNECTED = 0,
> NETLINK_CONNECTED,
>};
># 128 "include/linux/netlink.h"
>struct nlattr
>{
> __u16 nla_len;
> __u16 nla_type;
>};
># 155 "include/linux/netlink.h"
>
># 1 "include/linux/skbuff.h" 1
># 25 "include/linux/skbuff.h"
>
># 1 "include/linux/net.h" 1
># 25 "include/linux/net.h"
>struct poll_table_struct;
>struct pipe_inode_info;
>struct inode;
>struct net;
># 50 "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(__be32 daddr);
>extern u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport);
>extern u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
>          __be16 dport);
>extern __u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
>     __be16 sport, __be16 dport);
>extern __u32 secure_tcpv6_sequence_number(__be32 *saddr, __be32 *daddr,
>       __be16 sport, __be16 dport);
>extern u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
>           __be16 sport, __be16 dport);
>
>
>extern const 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);
># 63 "include/linux/net.h" 2
># 86 "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,
>};
>
>
>
>
>
>enum sock_shutdown_cmd {
> SHUT_RD = 0,
> SHUT_WR = 1,
> SHUT_RDWR = 2,
>};
># 117 "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);
> ssize_t (*splice_read)(struct socket *sock, loff_t *ppos,
>           struct pipe_inode_info *pipe, size_t len, unsigned int flags);
>};
>
>struct net_proto_family {
> int family;
> int (*create)(struct net *net, struct socket *sock, int protocol);
> struct module *owner;
>};
>
>struct iovec;
>struct kvec;
>
>enum {
> SOCK_WAKE_IO,
> SOCK_WAKE_WAITD,
> SOCK_WAKE_SPACE,
> SOCK_WAKE_URG,
>};
>
>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);
>extern int kernel_sock_shutdown(struct socket *sock,
>    enum sock_shutdown_cmd how);
># 341 "include/linux/net.h"
>extern int net_msg_cost;
>extern int net_msg_burst;
># 26 "include/linux/skbuff.h" 2
>
># 1 "include/linux/textsearch.h" 1
># 11 "include/linux/textsearch.h"
>struct ts_config;
># 23 "include/linux/textsearch.h"
>struct ts_state
>{
> unsigned int offset;
> char cb[40];
>};
># 39 "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;
># 74 "include/linux/textsearch.h"
> unsigned int (*get_next_block)(unsigned int consumed,
>        const u8 **dst,
>        struct ts_config *conf,
>        struct ts_state *state);
># 87 "include/linux/textsearch.h"
> void (*finish)(struct ts_config *conf,
>       struct ts_state *state);
>};
># 103 "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;
>}
># 122 "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)));
>}
># 27 "include/linux/skbuff.h" 2
>
># 1 "include/net/checksum.h" 1
># 26 "include/net/checksum.h"
>
># 1 "include/asm/checksum.h" 1
>
>
>
>
># 1 "arch/um/include/sysdep/checksum.h" 1
># 12 "arch/um/include/sysdep/checksum.h"
>extern __wsum csum_partial(const void *buff, int len, __wsum sum);
># 22 "arch/um/include/sysdep/checksum.h"
>static __inline__ __attribute__((always_inline))
>__wsum csum_partial_copy_nocheck(const void *src, void *dst,
>           int len, __wsum sum)
>{
> memcpy(dst, src, len);
> return(csum_partial(dst, len, sum));
>}
>
>static __inline__ __attribute__((always_inline))
>__wsum csum_partial_copy_from_user(const void *src,
>                                         void *dst, int len, __wsum sum,
>                                         int *err_ptr)
>{
>        if (copy_from_user(dst, src, len)) {
>                *err_ptr = -14;
>                return ( __wsum)-1;
>        }
>        return csum_partial(dst, len, sum);
>}
># 50 "arch/um/include/sysdep/checksum.h"
>static inline __attribute__((always_inline)) __sum16 csum_fold(__wsum sum)
>{
> __asm__(
>  "  addl %1,%0\n"
>  "  adcl $0xffff,%0"
>  : "=r" (sum)
>  : "r" (( u32)sum << 16),
>    "0" (( u32)sum & 0xffff0000)
> );
> return ( __sum16)(~( u32)sum >> 16);
>}
># 73 "arch/um/include/sysdep/checksum.h"
>static inline __attribute__((always_inline)) __wsum
>csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len,
>     unsigned short proto, __wsum sum)
>{
> asm("  addl %1, %0\n"
>     "  adcl %2, %0\n"
>     "  adcl %3, %0\n"
>     "  adcl $0, %0\n"
>  : "=r" (sum)
>     : "g" (daddr), "g" (saddr), "g" ((len + proto) << 8), "0" (sum));
> return sum;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) __sum16 csum_tcpudp_magic(__be32 saddr, __be32 daddr,
>        unsigned short len,
>        unsigned short proto,
>        __wsum sum)
>{
> return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
>{
> unsigned int sum;
>
> asm( "  movl (%1), %0\n"
>  "  subl $4, %2\n"
>  "  jbe 2f\n"
>  "  addl 4(%1), %0\n"
>  "  adcl 8(%1), %0\n"
>  "  adcl 12(%1), %0\n"
>  "1: adcl 16(%1), %0\n"
>  "  lea 4(%1), %1\n"
>  "  decl %2\n"
>  "  jne	1b\n"
>  "  adcl $0, %0\n"
>  "  movl %0, %2\n"
>  "  shrl $16, %0\n"
>  "  addw %w2, %w0\n"
>  "  adcl $0, %0\n"
>  "  notl %0\n"
>  "2:"
>
>
>
> : "=r" (sum), "=r" (iph), "=r" (ihl)
> : "1" (iph), "2" (ihl)
> : "memory");
> return ( __sum16)sum;
>}
>
>static inline __attribute__((always_inline)) unsigned add32_with_carry(unsigned a, unsigned b)
>{
>        asm("addl %2,%0\n\t"
>            "adcl $0,%0"
>            : "=r" (a)
>            : "0" (a), "r" (b));
>        return a;
>}
>
>extern __sum16 ip_compute_csum(const void *buff, int len);
># 5 "include/asm/checksum.h" 2
># 27 "include/net/checksum.h" 2
>
>
>static inline __attribute__((always_inline))
>__wsum csum_and_copy_from_user (const void *src, void *dst,
>          int len, __wsum sum, int *err_ptr)
>{
> if ((((unsigned long) (src) <= ((unsigned long) (src) + (len))) && ((((unsigned long) (src) < (task_size)) && (((unsigned long) (src) + (len)) < (task_size))) || ((0 == 0) && ((unsigned long) (src) >= 0) && ((unsigned long) (src) + (len) <= 0) && ((unsigned long) (src) + (len) >= (unsigned long)(src))) || (((current_thread_info()->addr_limit)).seg == (((mm_segment_t) { (0xFFFFFFFF) })).seg))))
>  return csum_partial_copy_from_user(src, dst, len, sum, err_ptr);
>
> if (len)
>  *err_ptr = -14;
>
> return sum;
>}
>
>
>
>static __inline__ __attribute__((always_inline)) __wsum csum_and_copy_to_user
>(const void *src, void *dst, int len, __wsum sum, int *err_ptr)
>{
> sum = csum_partial(src, len, sum);
>
> if ((((unsigned long) (dst) <= ((unsigned long) (dst) + (len))) && ((((unsigned long) (dst) < (task_size)) && (((unsigned long) (dst) + (len)) < (task_size))) || ((1 == 0) && ((unsigned long) (dst) >= 0) && ((unsigned long) (dst) + (len) <= 0) && ((unsigned long) (dst) + (len) >= (unsigned long)(dst))) || (((current_thread_info()->addr_limit)).seg == (((mm_segment_t) { (0xFFFFFFFF) })).seg)))) {
>  if (copy_to_user(dst, src, len) == 0)
>   return sum;
> }
> if (len)
>  *err_ptr = -14;
>
> return ( __wsum)-1;
>}
>
>
>static inline __attribute__((always_inline)) __wsum csum_add(__wsum csum, __wsum addend)
>{
> u32 res = ( u32)csum;
> res += ( u32)addend;
> return ( __wsum)(res + (res < ( u32)addend));
>}
>
>static inline __attribute__((always_inline)) __wsum csum_sub(__wsum csum, __wsum addend)
>{
> return csum_add(csum, ~addend);
>}
>
>static inline __attribute__((always_inline)) __wsum
>csum_block_add(__wsum csum, __wsum csum2, int offset)
>{
> u32 sum = ( u32)csum2;
> if (offset&1)
>  sum = ((sum&0xFF00FF)<<8)+((sum>>8)&0xFF00FF);
> return csum_add(csum, ( __wsum)sum);
>}
>
>static inline __attribute__((always_inline)) __wsum
>csum_block_sub(__wsum csum, __wsum csum2, int offset)
>{
> u32 sum = ( u32)csum2;
> if (offset&1)
>  sum = ((sum&0xFF00FF)<<8)+((sum>>8)&0xFF00FF);
> return csum_sub(csum, ( __wsum)sum);
>}
>
>static inline __attribute__((always_inline)) __wsum csum_unfold(__sum16 n)
>{
> return ( __wsum)n;
>}
>
>
>
>static inline __attribute__((always_inline)) void csum_replace4(__sum16 *sum, __be32 from, __be32 to)
>{
> __be32 diff[] = { ~from, to };
>
> *sum = csum_fold(csum_partial((char *)diff, sizeof(diff), ~csum_unfold(*sum)));
>}
>
>static inline __attribute__((always_inline)) void csum_replace2(__sum16 *sum, __be16 from, __be16 to)
>{
> csum_replace4(sum, ( __be32)from, ( __be32)to);
>}
>
>struct sk_buff;
>extern void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb,
>         __be32 from, __be32 to, int pseudohdr);
>
>static inline __attribute__((always_inline)) void inet_proto_csum_replace2(__sum16 *sum, struct sk_buff *skb,
>         __be16 from, __be16 to,
>         int pseudohdr)
>{
> inet_proto_csum_replace4(sum, skb, ( __be32)from,
>     ( __be32)to, pseudohdr);
>}
># 28 "include/linux/skbuff.h" 2
>
>
># 1 "include/linux/dmaengine.h" 1
># 29 "include/linux/dmaengine.h"
>
># 1 "include/linux/dma-mapping.h" 1
># 9 "include/linux/dma-mapping.h"
>enum dma_data_direction {
> DMA_BIDIRECTIONAL = 0,
> DMA_TO_DEVICE = 1,
> DMA_FROM_DEVICE = 2,
> DMA_NONE = 3,
>};
># 39 "include/linux/dma-mapping.h"
>static inline __attribute__((always_inline)) int valid_dma_direction(int dma_direction)
>{
> return ((dma_direction == DMA_BIDIRECTIONAL) ||
>  (dma_direction == DMA_TO_DEVICE) ||
>  (dma_direction == DMA_FROM_DEVICE));
>}
>
>static inline __attribute__((always_inline)) int is_device_dma_capable(struct device *dev)
>{
> return dev->dma_mask != ((void *)0) && *dev->dma_mask != 0x0ULL;
>}
>
>
>
># 1 "include/asm/dma-mapping.h" 1
>
>
>
>
>
>static inline __attribute__((always_inline)) int
>dma_supported(struct device *dev, u64 mask)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 9, (__func__)); panic("BUG!"); } while (0);
> return(0);
>}
>
>static inline __attribute__((always_inline)) int
>dma_set_mask(struct device *dev, u64 dma_mask)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 16, (__func__)); panic("BUG!"); } while (0);
> return(0);
>}
>
>static inline __attribute__((always_inline)) void *
>dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
>     gfp_t flag)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 24, (__func__)); panic("BUG!"); } while (0);
> return((void *) 0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
>    dma_addr_t dma_handle)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 32, (__func__)); panic("BUG!"); } while (0);
>}
>
>static inline __attribute__((always_inline)) dma_addr_t
>dma_map_single(struct device *dev, void *cpu_addr, size_t size,
>        enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 39, (__func__)); panic("BUG!"); } while (0);
> return(0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
>   enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 47, (__func__)); panic("BUG!"); } while (0);
>}
>
>static inline __attribute__((always_inline)) dma_addr_t
>dma_map_page(struct device *dev, struct page *page,
>      unsigned long offset, size_t size,
>      enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 55, (__func__)); panic("BUG!"); } while (0);
> return(0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
>        enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 63, (__func__)); panic("BUG!"); } while (0);
>}
>
>static inline __attribute__((always_inline)) int
>dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
>    enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 70, (__func__)); panic("BUG!"); } while (0);
> return(0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
>      enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 78, (__func__)); panic("BUG!"); } while (0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
>  enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 85, (__func__)); panic("BUG!"); } while (0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
>     enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 92, (__func__)); panic("BUG!"); } while (0);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int
>dma_get_cache_alignment(void)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 102, (__func__)); panic("BUG!"); } while (0);
> return(0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
>        unsigned long offset, size_t size,
>        enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 111, (__func__)); panic("BUG!"); } while (0);
>}
>
>static inline __attribute__((always_inline)) void
>dma_cache_sync(struct device *dev, void *vaddr, size_t size,
>        enum dma_data_direction direction)
>{
> do { printk("BUG: failure at %s:%d/%s()!\n", "include/asm/dma-mapping.h", 118, (__func__)); panic("BUG!"); } while (0);
>}
># 53 "include/linux/dma-mapping.h" 2
># 61 "include/linux/dma-mapping.h"
>extern u64 dma_get_required_mask(struct device *dev);
>
>static inline __attribute__((always_inline)) unsigned int dma_get_max_seg_size(struct device *dev)
>{
> return dev->dma_parms ? dev->dma_parms->max_segment_size : 65536;
>}
>
>static inline __attribute__((always_inline)) unsigned int dma_set_max_seg_size(struct device *dev,
>      unsigned int size)
>{
> if (dev->dma_parms) {
>  dev->dma_parms->max_segment_size = size;
>  return 0;
> } else
>  return -5;
>}
>
>static inline __attribute__((always_inline)) unsigned long dma_get_seg_boundary(struct device *dev)
>{
> return dev->dma_parms ?
>  dev->dma_parms->segment_boundary_mask : 0xffffffff;
>}
>
>static inline __attribute__((always_inline)) int dma_set_seg_boundary(struct device *dev, unsigned long mask)
>{
> if (dev->dma_parms) {
>  dev->dma_parms->segment_boundary_mask = mask;
>  return 0;
> } else
>  return -5;
>}
># 100 "include/linux/dma-mapping.h"
>static inline __attribute__((always_inline)) int
>dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
>       dma_addr_t device_addr, size_t size, int flags)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void
>dma_release_declared_memory(struct device *dev)
>{
>}
>
>static inline __attribute__((always_inline)) void *
>dma_mark_declared_memory_occupied(struct device *dev,
>      dma_addr_t device_addr, size_t size)
>{
> return ERR_PTR(-16);
>}
>
>
>
>
>
>extern void *dmam_alloc_coherent(struct device *dev, size_t size,
>     dma_addr_t *dma_handle, gfp_t gfp);
>extern void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
>          dma_addr_t dma_handle);
>extern void *dmam_alloc_noncoherent(struct device *dev, size_t size,
>        dma_addr_t *dma_handle, gfp_t gfp);
>extern void dmam_free_noncoherent(struct device *dev, size_t size, void *vaddr,
>      dma_addr_t dma_handle);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int dmam_declare_coherent_memory(struct device *dev,
>    dma_addr_t bus_addr, dma_addr_t device_addr,
>    size_t size, gfp_t gfp)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void dmam_release_declared_memory(struct device *dev)
>{
>}
>
>
>
>struct dma_attrs;
># 30 "include/linux/dmaengine.h" 2
># 38 "include/linux/dmaengine.h"
>enum dma_state {
> DMA_RESOURCE_SUSPEND,
> DMA_RESOURCE_RESUME,
> DMA_RESOURCE_AVAILABLE,
> DMA_RESOURCE_REMOVED,
>};
>
>
>
>
>
>
>
>enum dma_state_client {
> DMA_ACK,
> DMA_DUP,
> DMA_NAK,
>};
>
>
>
>
>
>
>typedef s32 dma_cookie_t;
># 72 "include/linux/dmaengine.h"
>enum dma_status {
> DMA_SUCCESS,
> DMA_IN_PROGRESS,
> DMA_ERROR,
>};
>
>
>
>
>enum dma_transaction_type {
> DMA_MEMCPY,
> DMA_XOR,
> DMA_PQ_XOR,
> DMA_DUAL_XOR,
> DMA_PQ_UPDATE,
> DMA_ZERO_SUM,
> DMA_PQ_ZERO_SUM,
> DMA_MEMSET,
> DMA_MEMCPY_CRC32C,
> DMA_INTERRUPT,
>};
># 106 "include/linux/dmaengine.h"
>enum dma_ctrl_flags {
> DMA_PREP_INTERRUPT = (1 << 0),
> DMA_CTRL_ACK = (1 << 1),
>};
>
>
>
>
>
>typedef struct { unsigned long bits[((((DMA_INTERRUPT + 1)) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))]; } dma_cap_mask_t;
># 124 "include/linux/dmaengine.h"
>struct dma_chan_percpu {
> local_t refcount;
>
> unsigned long memcpy_count;
> unsigned long bytes_transferred;
>};
># 143 "include/linux/dmaengine.h"
>struct dma_chan {
> struct dma_device *device;
> dma_cookie_t cookie;
>
>
> int chan_id;
> struct device dev;
>
> struct kref refcount;
> int slow_ref;
> struct rcu_head rcu;
>
> struct list_head device_node;
> struct dma_chan_percpu *local;
>};
>
>
>
>void dma_chan_cleanup(struct kref *kref);
>
>static inline __attribute__((always_inline)) void dma_chan_get(struct dma_chan *chan)
>{
> if (__builtin_expect(!!(chan->slow_ref), 0))
>  kref_get(&chan->refcount);
> else {
>  local_inc(&(({ (void)((({ do { } while (0); 0; }))); ((chan->local)); })->refcount));
>  do { } while (0);
> }
>}
>
>static inline __attribute__((always_inline)) void dma_chan_put(struct dma_chan *chan)
>{
> if (__builtin_expect(!!(chan->slow_ref), 0))
>  kref_put(&chan->refcount, dma_chan_cleanup);
> else {
>  local_dec(&(({ (void)((({ do { } while (0); 0; }))); ((chan->local)); })->refcount));
>  do { } while (0);
> }
>}
># 196 "include/linux/dmaengine.h"
>struct dma_client;
>typedef enum dma_state_client (*dma_event_callback) (struct dma_client *client,
>  struct dma_chan *chan, enum dma_state state);
># 207 "include/linux/dmaengine.h"
>struct dma_client {
> dma_event_callback event_callback;
> dma_cap_mask_t cap_mask;
> struct list_head global_node;
>};
>
>typedef void (*dma_async_tx_callback)(void *dma_async_param);
># 233 "include/linux/dmaengine.h"
>struct dma_async_tx_descriptor {
> dma_cookie_t cookie;
> enum dma_ctrl_flags flags;
> dma_addr_t phys;
> struct list_head tx_list;
> struct dma_chan *chan;
> dma_cookie_t (*tx_submit)(struct dma_async_tx_descriptor *tx);
> dma_async_tx_callback callback;
> void *callback_param;
> struct dma_async_tx_descriptor *next;
> struct dma_async_tx_descriptor *parent;
> spinlock_t lock;
>};
># 268 "include/linux/dmaengine.h"
>struct dma_device {
>
> unsigned int chancnt;
> struct list_head channels;
> struct list_head global_node;
> dma_cap_mask_t cap_mask;
> int max_xor;
>
> struct kref refcount;
> struct completion done;
>
> int dev_id;
> struct device *dev;
>
> int (*device_alloc_chan_resources)(struct dma_chan *chan);
> void (*device_free_chan_resources)(struct dma_chan *chan);
>
> struct dma_async_tx_descriptor *(*device_prep_dma_memcpy)(
>  struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
>  size_t len, unsigned long flags);
> struct dma_async_tx_descriptor *(*device_prep_dma_xor)(
>  struct dma_chan *chan, dma_addr_t dest, dma_addr_t *src,
>  unsigned int src_cnt, size_t len, unsigned long flags);
> struct dma_async_tx_descriptor *(*device_prep_dma_zero_sum)(
>  struct dma_chan *chan, dma_addr_t *src, unsigned int src_cnt,
>  size_t len, u32 *result, unsigned long flags);
> struct dma_async_tx_descriptor *(*device_prep_dma_memset)(
>  struct dma_chan *chan, dma_addr_t dest, int value, size_t len,
>  unsigned long flags);
> struct dma_async_tx_descriptor *(*device_prep_dma_interrupt)(
>  struct dma_chan *chan, unsigned long flags);
>
> enum dma_status (*device_is_tx_complete)(struct dma_chan *chan,
>   dma_cookie_t cookie, dma_cookie_t *last,
>   dma_cookie_t *used);
> void (*device_issue_pending)(struct dma_chan *chan);
>};
>
>
>
>void dma_async_client_register(struct dma_client *client);
>void dma_async_client_unregister(struct dma_client *client);
>void dma_async_client_chan_request(struct dma_client *client);
>dma_cookie_t dma_async_memcpy_buf_to_buf(struct dma_chan *chan,
> void *dest, void *src, size_t len);
>dma_cookie_t dma_async_memcpy_buf_to_pg(struct dma_chan *chan,
> struct page *page, unsigned int offset, void *kdata, size_t len);
>dma_cookie_t dma_async_memcpy_pg_to_pg(struct dma_chan *chan,
> struct page *dest_pg, unsigned int dest_off, struct page *src_pg,
> unsigned int src_off, size_t len);
>void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
> struct dma_chan *chan);
>
>static inline __attribute__((always_inline)) void
>async_tx_ack(struct dma_async_tx_descriptor *tx)
>{
> tx->flags |= DMA_CTRL_ACK;
>}
>
>static inline __attribute__((always_inline)) int
>async_tx_test_ack(struct dma_async_tx_descriptor *tx)
>{
> return tx->flags & DMA_CTRL_ACK;
>}
>
>
>static inline __attribute__((always_inline)) int __first_dma_cap(const dma_cap_mask_t *srcp)
>{
> return ({ int __min1 = ((DMA_INTERRUPT + 1)); int __min2 = (find_first_bit(srcp->bits, (DMA_INTERRUPT + 1))); __min1 < __min2 ? __min1: __min2; });
>
>}
>
>
>static inline __attribute__((always_inline)) int __next_dma_cap(int n, const dma_cap_mask_t *srcp)
>{
> return ({ int __min1 = ((DMA_INTERRUPT + 1)); int __min2 = (find_next_bit(srcp->bits, (DMA_INTERRUPT + 1), n+1)); __min1 < __min2 ? __min1: __min2; });
>
>}
>
>
>static inline __attribute__((always_inline)) void
>__dma_cap_set(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
>{
> set_bit(tx_type, dstp->bits);
>}
>
>
>static inline __attribute__((always_inline)) int
>__dma_has_cap(enum dma_transaction_type tx_type, dma_cap_mask_t *srcp)
>{
> return (__builtin_constant_p((tx_type)) ? constant_test_bit((tx_type), (srcp->bits)) : variable_test_bit((tx_type), (srcp->bits)));
>}
># 373 "include/linux/dmaengine.h"
>static inline __attribute__((always_inline)) void dma_async_issue_pending(struct dma_chan *chan)
>{
> chan->device->device_issue_pending(chan);
>}
># 391 "include/linux/dmaengine.h"
>static inline __attribute__((always_inline)) enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,
> dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)
>{
> return chan->device->device_is_tx_complete(chan, cookie, last, used);
>}
># 409 "include/linux/dmaengine.h"
>static inline __attribute__((always_inline)) enum dma_status dma_async_is_complete(dma_cookie_t cookie,
>   dma_cookie_t last_complete, dma_cookie_t last_used)
>{
> if (last_complete <= last_used) {
>  if ((cookie <= last_complete) || (cookie > last_used))
>   return DMA_SUCCESS;
> } else {
>  if ((cookie <= last_complete) && (cookie > last_used))
>   return DMA_SUCCESS;
> }
> return DMA_IN_PROGRESS;
>}
>
>enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie);
>
>
>
>int dma_async_device_register(struct dma_device *device);
>void dma_async_device_unregister(struct dma_device *device);
>
>
>
>struct dma_page_list {
> char *base_address;
> int nr_pages;
> struct page **pages;
>};
>
>struct dma_pinned_list {
> int nr_iovecs;
> struct dma_page_list page_list[0];
>};
>
>struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len);
>void dma_unpin_iovec_pages(struct dma_pinned_list* pinned_list);
>
>dma_cookie_t dma_memcpy_to_iovec(struct dma_chan *chan, struct iovec *iov,
> struct dma_pinned_list *pinned_list, unsigned char *kdata, size_t len);
>dma_cookie_t dma_memcpy_pg_to_iovec(struct dma_chan *chan, struct iovec *iov,
> struct dma_pinned_list *pinned_list, struct page *page,
> unsigned int offset, size_t len);
># 30 "include/linux/skbuff.h" 2
># 96 "include/linux/skbuff.h"
>struct net_device;
>struct scatterlist;
>struct pipe_inode_info;
># 116 "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;
> __u32 page_offset;
> __u32 size;
>};
>
>
>
>
>struct skb_shared_info {
> atomic_t dataref;
> unsigned short nr_frags;
> unsigned short gso_size;
>
> unsigned short gso_segs;
> unsigned short gso_type;
> __be32 ip6_frag_id;
> struct sk_buff *frag_list;
> skb_frag_t frags[(65536/((1UL) << 12) + 2)];
>};
># 168 "include/linux/skbuff.h"
>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,
>};
>
>
>
>
>
>
>typedef unsigned int sk_buff_data_t;
># 251 "include/linux/skbuff.h"
>struct sk_buff {
>
> struct sk_buff *next;
> struct sk_buff *prev;
>
> struct sock *sk;
> ktime_t tstamp;
> struct net_device *dev;
>
> union {
>  struct dst_entry *dst;
>  struct rtable *rtable;
> };
> struct sec_path *sp;
>
>
>
>
>
>
>
> char cb[48];
>
> unsigned int len,
>    data_len;
> __u16 mac_len,
>    hdr_len;
> union {
>  __wsum csum;
>  struct {
>   __u16 csum_start;
>   __u16 csum_offset;
>  };
> };
> __u32 priority;
> __u8 local_df:1,
>    cloned:1,
>    ip_summed:2,
>    nohdr:1,
>    nfctinfo:3;
> __u8 pkt_type:3,
>    fclone:2,
>    ipvs_property:1,
>    peeked:1,
>    nf_trace:1;
> __be16 protocol;
>
> void (*destructor)(struct sk_buff *skb);
># 307 "include/linux/skbuff.h"
> int iif;
># 329 "include/linux/skbuff.h"
> __u32 mark;
>
> sk_buff_data_t transport_header;
> sk_buff_data_t network_header;
> sk_buff_data_t mac_header;
>
> sk_buff_data_t tail;
> sk_buff_data_t end;
> unsigned char *head,
>    *data;
> unsigned int truesize;
> atomic_t users;
>};
># 351 "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, int node);
>static inline __attribute__((always_inline)) struct sk_buff *alloc_skb(unsigned int size,
>     gfp_t priority)
>{
> return __alloc_skb(size, priority, 0, -1);
>}
>
>static inline __attribute__((always_inline)) struct sk_buff *alloc_skb_fclone(unsigned int size,
>            gfp_t priority)
>{
> return __alloc_skb(size, priority, 1, -1);
>}
>
>extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
>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_to_sgvec(struct sk_buff *skb,
>        struct scatterlist *sg, int offset,
>        int len);
>extern int skb_cow_data(struct sk_buff *skb, int tailbits,
>        struct sk_buff **trailer);
>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)
>{
> int len = sizeof(struct sk_buff) + skb->len;
>
> if (__builtin_expect(!!((int)skb->truesize < 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);
>
>
>static inline __attribute__((always_inline)) unsigned char *skb_end_pointer(const struct sk_buff *skb)
>{
> return skb->head + skb->end;
>}
># 451 "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;
>}
># 463 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) struct sk_buff *skb_get(struct sk_buff *skb)
>{
> atomic_inc(&skb->users);
> return skb;
>}
># 482 "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_pointer(skb)))->dataref)->counter) & ((1 << 16) - 1)) != 1;
>}
># 495 "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_pointer(skb)))->dataref)->counter);
> dataref = (dataref & ((1 << 16) - 1)) - (dataref >> 16);
> return dataref != 1;
>}
># 515 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) void skb_header_release(struct sk_buff *skb)
>{
> do { if (__builtin_expect(!!(skb->nohdr), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/skbuff.h", 517, (__func__)); panic("BUG!"); } while (0); } while(0);
> skb->nohdr = 1;
> atomic_add(1 << 16, &((struct skb_shared_info *)(skb_end_pointer(skb)))->dataref);
>}
># 529 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) int skb_shared(const struct sk_buff *skb)
>{
> return ((&skb->users)->counter) != 1;
>}
># 547 "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;
>}
># 579 "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;
>}
># 604 "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;
>}
># 625 "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;
>}
># 652 "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;
>}
>
>static inline __attribute__((always_inline)) void skb_queue_head_init_class(struct sk_buff_head *list,
>  struct lock_class_key *class)
>{
> skb_queue_head_init(list);
> do { (void)(class); } while (0);
>}
>
>
>
>
>
>
>
>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++;
>}
># 694 "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)
>{
> __skb_insert(newsk, prev, prev->next, list);
>}
>
>extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,
>         struct sk_buff_head *list);
>
>static inline __attribute__((always_inline)) void __skb_queue_before(struct sk_buff_head *list,
>          struct sk_buff *next,
>          struct sk_buff *newsk)
>{
> __skb_insert(newsk, next->prev, next, list);
>}
># 721 "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);
>}
># 738 "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)
>{
> __skb_queue_before(list, (struct sk_buff *)list, newsk);
>}
>
>
>
>
>
>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;
>}
># 770 "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 *skb = skb_peek(list);
> if (skb)
>  __skb_unlink(skb, list);
> return skb;
>}
># 787 "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_pointer(skb)))->nr_frags - 1; i >= 0; i--)
>  len += ((struct skb_shared_info *)(skb_end_pointer(skb)))->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_pointer(skb)))->frags[i];
>
> frag->page = page;
> frag->page_offset = off;
> frag->size = size;
> ((struct skb_shared_info *)(skb_end_pointer(skb)))->nr_frags = i + 1;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned char *skb_tail_pointer(const struct sk_buff *skb)
>{
> return skb->head + skb->tail;
>}
>
>static inline __attribute__((always_inline)) void skb_reset_tail_pointer(struct sk_buff *skb)
>{
> skb->tail = skb->data - skb->head;
>}
>
>static inline __attribute__((always_inline)) void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
>{
> skb_reset_tail_pointer(skb);
> skb->tail += offset;
>}
># 868 "include/linux/skbuff.h"
>extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
>static inline __attribute__((always_inline)) unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
>{
> unsigned char *tmp = skb_tail_pointer(skb);
> do { if (__builtin_expect(!!(skb_is_nonlinear(skb)), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/skbuff.h", 872, (__func__)); panic("BUG!"); } while (0); } while(0);
> skb->tail += len;
> skb->len += len;
> return tmp;
>}
>
>extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
>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;
>}
>
>extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
>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)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/skbuff.h", 890, (__func__)); panic("BUG!"); } while (0); } while(0);
> return skb->data += 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)) unsigned 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;
>}
># 949 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) void skb_reserve(struct sk_buff *skb, int len)
>{
> skb->data += len;
> skb->tail += len;
>}
>
>
>static inline __attribute__((always_inline)) unsigned char *skb_transport_header(const struct sk_buff *skb)
>{
> return skb->head + skb->transport_header;
>}
>
>static inline __attribute__((always_inline)) void skb_reset_transport_header(struct sk_buff *skb)
>{
> skb->transport_header = skb->data - skb->head;
>}
>
>static inline __attribute__((always_inline)) void skb_set_transport_header(struct sk_buff *skb,
>         const int offset)
>{
> skb_reset_transport_header(skb);
> skb->transport_header += offset;
>}
>
>static inline __attribute__((always_inline)) unsigned char *skb_network_header(const struct sk_buff *skb)
>{
> return skb->head + skb->network_header;
>}
>
>static inline __attribute__((always_inline)) void skb_reset_network_header(struct sk_buff *skb)
>{
> skb->network_header = skb->data - skb->head;
>}
>
>static inline __attribute__((always_inline)) void skb_set_network_header(struct sk_buff *skb, const int offset)
>{
> skb_reset_network_header(skb);
> skb->network_header += offset;
>}
>
>static inline __attribute__((always_inline)) unsigned char *skb_mac_header(const struct sk_buff *skb)
>{
> return skb->head + skb->mac_header;
>}
>
>static inline __attribute__((always_inline)) int skb_mac_header_was_set(const struct sk_buff *skb)
>{
> return skb->mac_header != ~0U;
>}
>
>static inline __attribute__((always_inline)) void skb_reset_mac_header(struct sk_buff *skb)
>{
> skb->mac_header = skb->data - skb->head;
>}
>
>static inline __attribute__((always_inline)) void skb_set_mac_header(struct sk_buff *skb, const int offset)
>{
> skb_reset_mac_header(skb);
> skb->mac_header += offset;
>}
># 1064 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) int skb_transport_offset(const struct sk_buff *skb)
>{
> return skb_transport_header(skb) - skb->data;
>}
>
>static inline __attribute__((always_inline)) u32 skb_network_header_len(const struct sk_buff *skb)
>{
> return skb->transport_header - skb->network_header;
>}
>
>static inline __attribute__((always_inline)) int skb_network_offset(const struct sk_buff *skb)
>{
> return skb_network_header(skb) - skb->data;
>}
># 1122 "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)) {
>  ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("include/linux/skbuff.h", 1127); __builtin_expect(!!(__ret_warn_on), 0); });
>  return;
> }
> skb->len = len;
> skb_set_tail_pointer(skb, len);
>}
>
>extern void skb_trim(struct sk_buff *skb, unsigned int 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;
>}
># 1158 "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)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/skbuff.h", 1161, (__func__)); panic("BUG!"); } while (0); } while(0);
>}
># 1172 "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);
>}
># 1188 "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);
>}
># 1208 "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;
>}
>
>extern struct sk_buff *dev_alloc_skb(unsigned int length);
>
>extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
>  unsigned int length, gfp_t gfp_mask);
># 1235 "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)));
>}
># 1249 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) int skb_clone_writable(struct sk_buff *skb, unsigned int len)
>{
> return !skb_header_cloned(skb) &&
>        skb_headroom(skb) + len <= skb->hdr_len;
>}
>
>static inline __attribute__((always_inline)) int __skb_cow(struct sk_buff *skb, unsigned int headroom,
>       int cloned)
>{
> int delta = 0;
>
> if (headroom < 16)
>  headroom = 16;
> if (headroom > skb_headroom(skb))
>  delta = headroom - skb_headroom(skb);
>
> if (delta || cloned)
>  return pskb_expand_head(skb, (((delta)+((typeof(delta))(16)-1))&~((typeof(delta))(16)-1)), 0,
>     ((( gfp_t)0x20u)));
> return 0;
>}
># 1283 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) int skb_cow(struct sk_buff *skb, unsigned int headroom)
>{
> return __skb_cow(skb, headroom, skb_cloned(skb));
>}
># 1298 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
>{
> return __skb_cow(skb, headroom, skb_header_cloned(skb));
>}
># 1314 "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;
>  __wsum 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_pointer(skb)))->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;
>}
># 1366 "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;
>}
># 1378 "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;
>}
># 1395 "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 == 2)
>  skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
>}
>
>unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
># 1413 "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 == 2)
>  skb->ip_summed = 0;
> return __pskb_trim(skb, len);
>}
># 1438 "include/linux/skbuff.h"
>extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
>        int *peeked, int *err);
>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 int skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
>      unsigned int flags);
>extern __wsum skb_checksum(const struct sk_buff *skb, int offset,
>        int len, __wsum csum);
>extern int skb_copy_bits(const struct sk_buff *skb, int offset,
>         void *to, int len);
>extern int skb_store_bits(struct sk_buff *skb, int offset,
>          const void *from, int len);
>extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb,
>           int offset, u8 *to, int len,
>           __wsum csum);
>extern int skb_splice_bits(struct sk_buff *skb,
>      unsigned int offset,
>      struct pipe_inode_info *pipe,
>      unsigned int len,
>      unsigned int flags);
>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;
>}
>
>static inline __attribute__((always_inline)) void skb_copy_from_linear_data(const struct sk_buff *skb,
>          void *to,
>          const unsigned int len)
>{
> memcpy(to, skb->data, len);
>}
>
>static inline __attribute__((always_inline)) void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
>          const int offset, void *to,
>          const unsigned int len)
>{
> memcpy(to, skb->data + offset, len);
>}
>
>static inline __attribute__((always_inline)) void skb_copy_to_linear_data(struct sk_buff *skb,
>        const void *from,
>        const unsigned int len)
>{
> memcpy(skb->data, from, len);
>}
>
>static inline __attribute__((always_inline)) void skb_copy_to_linear_data_offset(struct sk_buff *skb,
>        const int offset,
>        const void *from,
>        const unsigned int len)
>{
> memcpy(skb->data + offset, from, len);
>}
>
>extern void skb_init(void);
># 1527 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) void skb_get_timestamp(const struct sk_buff *skb, struct timeval *stamp)
>{
> *stamp = ns_to_timeval((skb->tstamp).tv64);
>}
>
>static inline __attribute__((always_inline)) void __net_timestamp(struct sk_buff *skb)
>{
> skb->tstamp = ktime_get_real();
>}
>
>static inline __attribute__((always_inline)) ktime_t net_timedelta(ktime_t t)
>{
> return ({ (ktime_t){ .tv64 = (ktime_get_real()).tv64 - (t).tv64 }; });
>}
>
>static inline __attribute__((always_inline)) ktime_t net_invalid_timestamp(void)
>{
> return ktime_set(0, 0);
>}
>
>extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
>extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
>
>static inline __attribute__((always_inline)) int skb_csum_unnecessary(const struct sk_buff *skb)
>{
> return skb->ip_summed & 1;
>}
># 1571 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) __sum16 skb_checksum_complete(struct sk_buff *skb)
>{
> return skb_csum_unnecessary(skb) ?
>        0 : __skb_checksum_complete(skb);
>}
># 1612 "include/linux/skbuff.h"
>static inline __attribute__((always_inline)) void nf_reset(struct sk_buff *skb)
>{
># 1624 "include/linux/skbuff.h"
>}
>
>
>static inline __attribute__((always_inline)) void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
>{
># 1640 "include/linux/skbuff.h"
>}
>
>static inline __attribute__((always_inline)) void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
>{
>
>
>
>
>
>
>
> __nf_copy(dst, src);
>}
># 1665 "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)) void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
>{
>
>
>
>}
>
>static inline __attribute__((always_inline)) u16 skb_get_queue_mapping(struct sk_buff *skb)
>{
>
>
>
> return 0;
>
>}
>
>static inline __attribute__((always_inline)) void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
>{
>
>
>
>}
>
>static inline __attribute__((always_inline)) int skb_is_gso(const struct sk_buff *skb)
>{
> return ((struct skb_shared_info *)(skb_end_pointer(skb)))->gso_size;
>}
>
>static inline __attribute__((always_inline)) int skb_is_gso_v6(const struct sk_buff *skb)
>{
> return ((struct skb_shared_info *)(skb_end_pointer(skb)))->gso_type & SKB_GSO_TCPV6;
>}
>
>static inline __attribute__((always_inline)) void skb_forward_csum(struct sk_buff *skb)
>{
>
> if (skb->ip_summed == 2)
>  skb->ip_summed = 0;
>}
>
>bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
># 156 "include/linux/netlink.h" 2
>
>static inline __attribute__((always_inline)) struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb)
>{
> return (struct nlmsghdr *)skb->data;
>}
>
>struct netlink_skb_parms
>{
> struct ucred creds;
> __u32 pid;
> __u32 dst_group;
> kernel_cap_t eff_cap;
> __u32 loginuid;
> __u32 sessionid;
> __u32 sid;
>};
>
>
>
>
>
>extern struct sock *netlink_kernel_create(struct net *net,
>       int unit,unsigned int groups,
>       void (*input)(struct sk_buff *skb),
>       struct mutex *cb_mutex,
>       struct module *module);
>extern void netlink_kernel_release(struct sock *sk);
>extern int netlink_change_ngroups(struct sock *sk, unsigned int groups);
>extern void netlink_clear_multicast_users(struct sock *sk, unsigned int group);
>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);
># 216 "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[6];
>};
>
>struct netlink_notify
>{
> struct net *net;
> 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;
>}
># 257 "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/genetlink.h" 2
>
>
>
>
>
>
>struct genlmsghdr {
> __u8 cmd;
> __u8 version;
> __u16 reserved;
>};
># 34 "include/linux/genetlink.h"
>enum {
> CTRL_CMD_UNSPEC,
> CTRL_CMD_NEWFAMILY,
> CTRL_CMD_DELFAMILY,
> CTRL_CMD_GETFAMILY,
> CTRL_CMD_NEWOPS,
> CTRL_CMD_DELOPS,
> CTRL_CMD_GETOPS,
> CTRL_CMD_NEWMCAST_GRP,
> CTRL_CMD_DELMCAST_GRP,
> CTRL_CMD_GETMCAST_GRP,
> __CTRL_CMD_MAX,
>};
>
>
>
>enum {
> CTRL_ATTR_UNSPEC,
> CTRL_ATTR_FAMILY_ID,
> CTRL_ATTR_FAMILY_NAME,
> CTRL_ATTR_VERSION,
> CTRL_ATTR_HDRSIZE,
> CTRL_ATTR_MAXATTR,
> CTRL_ATTR_OPS,
> CTRL_ATTR_MCAST_GROUPS,
> __CTRL_ATTR_MAX,
>};
>
>
>
>enum {
> CTRL_ATTR_OP_UNSPEC,
> CTRL_ATTR_OP_ID,
> CTRL_ATTR_OP_FLAGS,
> __CTRL_ATTR_OP_MAX,
>};
>
>
>
>enum {
> CTRL_ATTR_MCAST_GRP_UNSPEC,
> CTRL_ATTR_MCAST_GRP_NAME,
> CTRL_ATTR_MCAST_GRP_ID,
> __CTRL_ATTR_MCAST_GRP_MAX,
>};
># 5 "include/net/genetlink.h" 2
>
># 1 "include/net/netlink.h" 1
># 168 "include/net/netlink.h"
>enum {
> NLA_UNSPEC,
> NLA_U8,
> NLA_U16,
> NLA_U32,
> NLA_U64,
> NLA_STRING,
> NLA_FLAG,
> NLA_MSECS,
> NLA_NESTED,
> NLA_NESTED_COMPAT,
> NLA_NUL_STRING,
> NLA_BINARY,
> __NLA_TYPE_MAX,
>};
># 209 "include/net/netlink.h"
>struct nla_policy {
> u16 type;
> u16 len;
>};
>
>
>
>
>
>
>struct nl_info {
> struct nlmsghdr *nlh;
> struct net *nl_net;
> u32 pid;
>};
>
>extern int netlink_rcv_skb(struct sk_buff *skb,
>     int (*cb)(struct sk_buff *,
>        struct nlmsghdr *));
>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,
>         const struct nla_policy *policy);
>extern int nla_parse(struct nlattr *tb[], int maxtype,
>      struct nlattr *head, int len,
>      const 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);
>extern int nla_append(struct sk_buff *skb, int attrlen,
>       const void *data);
># 269 "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);
>}
># 352 "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);
>}
># 371 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen,
>         struct nlattr *tb[], int maxtype,
>         const 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);
>}
># 390 "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);
>}
># 404 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
>     const 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);
>}
># 483 "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);
>}
># 503 "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);
>}
># 520 "include/net/netlink.h"
>static inline __attribute__((always_inline)) struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
>{
> return alloc_skb(nlmsg_total_size(payload), flags);
>}
># 536 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
>{
> nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
>
> return skb->len;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void *nlmsg_get_pos(struct sk_buff *skb)
>{
> return skb_tail_pointer(skb);
>}
># 561 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nlmsg_trim(struct sk_buff *skb, const void *mark)
>{
> if (mark)
>  skb_trim(skb, (unsigned char *) mark - skb->data);
>
> return -1;
>}
># 577 "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);
>}
># 599 "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;
>}
># 650 "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)) int nla_type(const struct nlattr *nla)
>{
> return nla->nla_type & ~((1 << 15) | (1 << 14));
>}
>
>
>
>
>
>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;
>}
># 720 "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);
>}
># 735 "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);
>}
># 749 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nla_parse_nested(struct nlattr *tb[], int maxtype,
>       struct nlattr *nla,
>       const struct nla_policy *policy)
>{
> return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
>}
># 770 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int __nla_parse_nested_compat(struct nlattr *tb[], int maxtype,
>         struct nlattr *nla,
>         const struct nla_policy *policy,
>         int len)
>{
> int nested_len = nla_len(nla) - (((len) + 4 - 1) & ~(4 - 1));
>
> if (nested_len < 0)
>  return -1;
> if (nested_len >= nla_attr_size(0))
>  return nla_parse(tb, maxtype, nla_data(nla) + (((len) + 4 - 1) & ~(4 - 1)),
>     nested_len, policy);
> memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
> return 0;
>}
># 795 "include/net/netlink.h"
>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);
>}
># 914 "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)) __be16 nla_get_be16(struct nlattr *nla)
>{
> return *(__be16 *) nla_data(nla);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) __le16 nla_get_le16(struct nlattr *nla)
>{
> return *(__le16 *) 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);
>}
># 1006 "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_pointer(skb);
>
> if (nla_put(skb, attrtype, 0, ((void *)0)) < 0)
>  return ((void *)0);
>
> return start;
>}
># 1026 "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_pointer(skb) - (unsigned char *)start;
> return skb->len;
>}
># 1044 "include/net/netlink.h"
>static inline __attribute__((always_inline)) struct nlattr *nla_nest_compat_start(struct sk_buff *skb,
>         int attrtype, int attrlen,
>         const void *data)
>{
> struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
>
> if (nla_put(skb, attrtype, attrlen, data) < 0)
>  return ((void *)0);
> if (nla_nest_start(skb, attrtype) == ((void *)0)) {
>  nlmsg_trim(skb, start);
>  return ((void *)0);
> }
> return start;
>}
># 1069 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nla_nest_compat_end(struct sk_buff *skb, struct nlattr *start)
>{
> struct nlattr *nest = (void *)start + ( ((start->nla_len)+4 -1) & ~(4 -1) );
>
> start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
> return nla_nest_end(skb, nest);
>}
># 1085 "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);
>}
># 1102 "include/net/netlink.h"
>static inline __attribute__((always_inline)) int nla_validate_nested(struct nlattr *start, int maxtype,
>          const struct nla_policy *policy)
>{
> return nla_validate(nla_data(start), nla_len(start), maxtype, policy);
>}
># 6 "include/net/genetlink.h" 2
># 15 "include/net/genetlink.h"
>struct genl_multicast_group
>{
> struct genl_family *family;
> struct list_head list;
> char name[16];
> u32 id;
>};
># 35 "include/net/genetlink.h"
>struct genl_family
>{
> unsigned int id;
> unsigned int hdrsize;
> char name[16];
> unsigned int version;
> unsigned int maxattr;
> struct nlattr ** attrbuf;
> struct list_head ops_list;
> struct list_head family_list;
> struct list_head mcast_groups;
>};
># 57 "include/net/genetlink.h"
>struct genl_info
>{
> u32 snd_seq;
> u32 snd_pid;
> struct nlmsghdr * nlhdr;
> struct genlmsghdr * genlhdr;
> void * userhdr;
> struct nlattr ** attrs;
>};
># 77 "include/net/genetlink.h"
>struct genl_ops
>{
> u8 cmd;
> unsigned int flags;
> const struct nla_policy *policy;
> int (*doit)(struct sk_buff *skb,
>           struct genl_info *info);
> int (*dumpit)(struct sk_buff *skb,
>      struct netlink_callback *cb);
> int (*done)(struct netlink_callback *cb);
> struct list_head ops_list;
>};
>
>extern int genl_register_family(struct genl_family *family);
>extern int genl_unregister_family(struct genl_family *family);
>extern int genl_register_ops(struct genl_family *, struct genl_ops *ops);
>extern int genl_unregister_ops(struct genl_family *, struct genl_ops *ops);
>extern int genl_register_mc_group(struct genl_family *family,
>      struct genl_multicast_group *grp);
>extern void genl_unregister_mc_group(struct genl_family *family,
>         struct genl_multicast_group *grp);
>
>extern struct sock *genl_sock;
># 112 "include/net/genetlink.h"
>static inline __attribute__((always_inline)) void *genlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
>    struct genl_family *family, int flags, u8 cmd)
>{
> struct nlmsghdr *nlh;
> struct genlmsghdr *hdr;
>
> nlh = nlmsg_put(skb, pid, seq, family->id, ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) ) +
>   family->hdrsize, flags);
> if (nlh == ((void *)0))
>  return ((void *)0);
>
> hdr = nlmsg_data(nlh);
> hdr->cmd = cmd;
> hdr->version = family->version;
> hdr->reserved = 0;
>
> return (char *) hdr + ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) );
>}
># 141 "include/net/genetlink.h"
>static inline __attribute__((always_inline)) void *genlmsg_put_reply(struct sk_buff *skb,
>          struct genl_info *info,
>          struct genl_family *family,
>          int flags, u8 cmd)
>{
> return genlmsg_put(skb, info->snd_pid, info->snd_seq, family,
>      flags, cmd);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_end(struct sk_buff *skb, void *hdr)
>{
> return nlmsg_end(skb, hdr - ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) ) - ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_cancel(struct sk_buff *skb, void *hdr)
>{
> return nlmsg_cancel(skb, hdr - ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) ) - ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )));
>}
># 177 "include/net/genetlink.h"
>static inline __attribute__((always_inline)) int genlmsg_multicast(struct sk_buff *skb, u32 pid,
>        unsigned int group, gfp_t flags)
>{
> return nlmsg_multicast(genl_sock, skb, pid, group, flags);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_unicast(struct sk_buff *skb, u32 pid)
>{
> return nlmsg_unicast(genl_sock, skb, pid);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_reply(struct sk_buff *skb, struct genl_info *info)
>{
> return genlmsg_unicast(skb, info->snd_pid);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void *genlmsg_data(const struct genlmsghdr *gnlh)
>{
> return ((unsigned char *) gnlh + ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) ));
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_len(const struct genlmsghdr *gnlh)
>{
> struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh -
>       ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )));
> return (nlh->nlmsg_len - ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) ) - ((int) ( ((sizeof(struct nlmsghdr))+4 -1) & ~(4 -1) )));
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_msg_size(int payload)
>{
> return ( ((sizeof(struct genlmsghdr))+4 -1) & ~(4 -1) ) + payload;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int genlmsg_total_size(int payload)
>{
> return ( ((genlmsg_msg_size(payload))+4 -1) & ~(4 -1) );
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) struct sk_buff *genlmsg_new(size_t payload, gfp_t flags)
>{
> return nlmsg_new(genlmsg_total_size(payload), flags);
>}
># 13 "include/linux/taskstats_kern.h" 2
># 32 "include/linux/taskstats_kern.h"
>static inline __attribute__((always_inline)) void taskstats_exit(struct task_struct *tsk, int group_dead)
>{}
>static inline __attribute__((always_inline)) void taskstats_tgid_init(struct signal_struct *sig)
>{}
>static inline __attribute__((always_inline)) void taskstats_tgid_free(struct signal_struct *sig)
>{}
>static inline __attribute__((always_inline)) void taskstats_init_early(void)
>{}
># 22 "include/linux/delayacct.h" 2
># 111 "include/linux/delayacct.h"
>static inline __attribute__((always_inline)) void delayacct_set_flag(int flag)
>{}
>static inline __attribute__((always_inline)) void delayacct_clear_flag(int flag)
>{}
>static inline __attribute__((always_inline)) void delayacct_init(void)
>{}
>static inline __attribute__((always_inline)) void delayacct_tsk_init(struct task_struct *tsk)
>{}
>static inline __attribute__((always_inline)) void delayacct_tsk_free(struct task_struct *tsk)
>{}
>static inline __attribute__((always_inline)) void delayacct_blkio_start(void)
>{}
>static inline __attribute__((always_inline)) void delayacct_blkio_end(void)
>{}
>static inline __attribute__((always_inline)) int delayacct_add_tsk(struct taskstats *d,
>     struct task_struct *tsk)
>{ return 0; }
>static inline __attribute__((always_inline)) __u64 delayacct_blkio_ticks(struct task_struct *tsk)
>{ return 0; }
>static inline __attribute__((always_inline)) int delayacct_is_task_waiting_on_io(struct task_struct *p)
>{ return 0; }
># 65 "kernel/sched.c" 2
>
># 1 "include/linux/reciprocal_div.h" 1
># 25 "include/linux/reciprocal_div.h"
>extern u32 reciprocal_value(u32 B);
>
>
>static inline __attribute__((always_inline)) u32 reciprocal_divide(u32 A, u32 R)
>{
> return (u32)(((u64)A * R) >> 32);
>}
># 66 "kernel/sched.c" 2
>
># 1 "include/linux/unistd.h" 1
>
>
>
>
>
>
>
># 1 "include/asm/unistd.h" 1
># 13 "include/asm/unistd.h"
>extern int um_execve(const char *file, char *const argv[], char *const env[]);
># 39 "include/asm/unistd.h"
>
># 1 "include/asm/arch/unistd.h" 1
>
>
>
>
>
># 1 "include/asm/arch/unistd_64.h" 1
># 16 "include/asm/arch/unistd_64.h"
># 6 "include/asm/arch/unistd.h" 2
># 40 "include/asm/unistd.h" 2
># 8 "include/linux/unistd.h" 2
># 67 "kernel/sched.c" 2
>
>
>
># 1 "include/linux/tick.h" 1
># 9 "include/linux/tick.h"
>
># 1 "include/linux/clockchips.h" 1
># 13 "include/linux/clockchips.h"
>
># 1 "include/linux/clocksource.h" 1
># 21 "include/linux/clocksource.h"
>typedef u64 cycle_t;
>struct clocksource;
># 56 "include/linux/clocksource.h"
>struct clocksource {
>
>
>
> char *name;
> struct list_head list;
> int rating;
> cycle_t (*read)(void);
> cycle_t mask;
> u32 mult;
> u32 shift;
> unsigned long flags;
> cycle_t (*vread)(void);
> void (*resume)(void);
># 78 "include/linux/clocksource.h"
> cycle_t cycle_interval;
> u64 xtime_interval;
>
>
>
>
>
> cycle_t cycle_last ;
> u64 xtime_nsec;
> s64 error;
>
>
>
>
>
>
>};
>
>extern struct clocksource *clock;
># 118 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
>{
>
>
>
>
>
>
>
> u64 tmp = ((u64)1000000) << shift_constant;
>
> tmp += khz/2;
> ({ uint32_t __base = (khz); uint32_t __rem; __rem = ((uint64_t)(tmp)) % __base; (tmp) = ((uint64_t)(tmp)) / __base; __rem; });
>
> return (u32)tmp;
>}
># 144 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) u32 clocksource_hz2mult(u32 hz, u32 shift_constant)
>{
>
>
>
>
>
>
>
> u64 tmp = ((u64)1000000000) << shift_constant;
>
> tmp += hz/2;
> ({ uint32_t __base = (hz); uint32_t __rem; __rem = ((uint64_t)(tmp)) % __base; (tmp) = ((uint64_t)(tmp)) / __base; __rem; });
>
> return (u32)tmp;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) cycle_t clocksource_read(struct clocksource *cs)
>{
> return cs->read();
>}
># 181 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) s64 cyc2ns(struct clocksource *cs, cycle_t cycles)
>{
> u64 ret = (u64)cycles;
> ret = (ret * cs->mult) >> cs->shift;
> return ret;
>}
># 199 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) void clocksource_calculate_interval(struct clocksource *c,
>          unsigned long length_nsec)
>{
> u64 tmp;
>
>
> tmp = length_nsec;
> tmp <<= c->shift;
> tmp += c->mult/2;
> ({ uint32_t __base = (c->mult); uint32_t __rem; __rem = ((uint64_t)(tmp)) % __base; (tmp) = ((uint64_t)(tmp)) / __base; __rem; });
>
> c->cycle_interval = (cycle_t)tmp;
> if (c->cycle_interval == 0)
>  c->cycle_interval = 1;
>
> c->xtime_interval = (u64)c->cycle_interval * c->mult;
>}
>
>
>
>extern int clocksource_register(struct clocksource*);
>extern void clocksource_unregister(struct clocksource*);
>extern void clocksource_touch_watchdog(void);
>extern struct clocksource* clocksource_get_next(void);
>extern void clocksource_change_rating(struct clocksource *cs, int rating);
>extern void clocksource_resume(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) void update_vsyscall(struct timespec *ts, struct clocksource *c)
>{
>}
>
>static inline __attribute__((always_inline)) void update_vsyscall_tz(void)
>{
>}
># 14 "include/linux/clockchips.h" 2
>
>
>
>
>struct clock_event_device;
>
>
>enum clock_event_mode {
> CLOCK_EVT_MODE_UNUSED = 0,
> CLOCK_EVT_MODE_SHUTDOWN,
> CLOCK_EVT_MODE_PERIODIC,
> CLOCK_EVT_MODE_ONESHOT,
> CLOCK_EVT_MODE_RESUME,
>};
>
>
>enum clock_event_nofitiers {
> CLOCK_EVT_NOTIFY_ADD,
> CLOCK_EVT_NOTIFY_BROADCAST_ON,
> CLOCK_EVT_NOTIFY_BROADCAST_OFF,
> CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
> CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
> CLOCK_EVT_NOTIFY_BROADCAST_EXIT,
> CLOCK_EVT_NOTIFY_SUSPEND,
> CLOCK_EVT_NOTIFY_RESUME,
> CLOCK_EVT_NOTIFY_CPU_DEAD,
>};
># 76 "include/linux/clockchips.h"
>struct clock_event_device {
> const char *name;
> unsigned int features;
> unsigned long max_delta_ns;
> unsigned long min_delta_ns;
> unsigned long mult;
> int shift;
> int rating;
> int irq;
> cpumask_t cpumask;
> int (*set_next_event)(unsigned long evt,
>        struct clock_event_device *);
> void (*set_mode)(enum clock_event_mode mode,
>         struct clock_event_device *);
> void (*event_handler)(struct clock_event_device *);
> void (*broadcast)(cpumask_t mask);
> struct list_head list;
> enum clock_event_mode mode;
> ktime_t next_event;
>};
># 108 "include/linux/clockchips.h"
>static inline __attribute__((always_inline)) unsigned long div_sc(unsigned long ticks, unsigned long nsec,
>       int shift)
>{
> uint64_t tmp = ((uint64_t)ticks) << shift;
>
> ({ uint32_t __base = (nsec); uint32_t __rem; __rem = ((uint64_t)(tmp)) % __base; (tmp) = ((uint64_t)(tmp)) / __base; __rem; });
> return (unsigned long) tmp;
>}
>
>
>extern unsigned long clockevent_delta2ns(unsigned long latch,
>      struct clock_event_device *evt);
>extern void clockevents_register_device(struct clock_event_device *dev);
>
>extern void clockevents_exchange_device(struct clock_event_device *old,
>     struct clock_event_device *new);
>extern void clockevents_set_mode(struct clock_event_device *dev,
>     enum clock_event_mode mode);
>extern int clockevents_register_notifier(struct notifier_block *nb);
>extern int clockevents_program_event(struct clock_event_device *dev,
>         ktime_t expires, ktime_t now);
>
>
>extern void clockevents_notify(unsigned long reason, void *arg);
># 10 "include/linux/tick.h" 2
>
>
>
>enum tick_device_mode {
> TICKDEV_MODE_PERIODIC,
> TICKDEV_MODE_ONESHOT,
>};
>
>struct tick_device {
> struct clock_event_device *evtdev;
> enum tick_device_mode mode;
>};
>
>enum tick_nohz_mode {
> NOHZ_MODE_INACTIVE,
> NOHZ_MODE_LOWRES,
> NOHZ_MODE_HIGHRES,
>};
># 47 "include/linux/tick.h"
>struct tick_sched {
> struct hrtimer sched_timer;
> unsigned long check_clocks;
> enum tick_nohz_mode nohz_mode;
> ktime_t idle_tick;
> int tick_stopped;
> unsigned long idle_jiffies;
> unsigned long idle_calls;
> unsigned long idle_sleeps;
> int idle_active;
> ktime_t idle_entrytime;
> ktime_t idle_waketime;
> ktime_t idle_exittime;
> ktime_t idle_sleeptime;
> ktime_t idle_lastupdate;
> ktime_t sleep_length;
> unsigned long last_jiffies;
> unsigned long next_jiffies;
> ktime_t idle_expires;
>};
>
>extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) tick_init(void);
>extern int tick_is_oneshot_available(void);
>extern struct tick_device *tick_get_device(int cpu);
>
>
>extern int tick_init_highres(void);
>extern int tick_program_event(ktime_t expires, int force);
>extern void tick_setup_sched_timer(void);
>extern void tick_cancel_sched_timer(int cpu);
># 92 "include/linux/tick.h"
>extern void tick_clock_notify(void);
>extern int tick_check_oneshot_change(int allow_nohz);
>extern struct tick_sched *tick_get_tick_sched(int cpu);
># 108 "include/linux/tick.h"
>extern void tick_nohz_stop_sched_tick(void);
>extern void tick_nohz_restart_sched_tick(void);
>extern void tick_nohz_update_jiffies(void);
>extern ktime_t tick_nohz_get_sleep_length(void);
>extern void tick_nohz_stop_idle(int cpu);
>extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);
># 70 "kernel/sched.c" 2
>
># 1 "include/linux/bootmem.h" 1
># 9 "include/linux/bootmem.h"
># 1 "include/asm/dma.h" 1
>
>
>
>
>
>extern unsigned long uml_physmem;
># 9 "include/linux/bootmem.h" 2
>
>
>
>
>
>extern unsigned long max_low_pfn;
>extern unsigned long min_low_pfn;
>
>
>
>
>extern unsigned long max_pfn;
># 30 "include/linux/bootmem.h"
>typedef struct bootmem_data {
> unsigned long node_boot_start;
> unsigned long node_low_pfn;
> void *node_bootmem_map;
> unsigned long last_offset;
> unsigned long last_pos;
> unsigned long last_success;
>
> struct list_head list;
>} bootmem_data_t;
>
>extern unsigned long bootmem_bootmap_pages(unsigned long);
>extern unsigned long init_bootmem(unsigned long addr, unsigned long memend);
>extern void free_bootmem(unsigned long addr, unsigned long size);
>extern void *__alloc_bootmem(unsigned long size,
>        unsigned long align,
>        unsigned long goal);
>extern void *__alloc_bootmem_nopanic(unsigned long size,
>         unsigned long align,
>         unsigned long goal);
>extern void *__alloc_bootmem_low(unsigned long size,
>     unsigned long align,
>     unsigned long goal);
>extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
>          unsigned long size,
>          unsigned long align,
>          unsigned long goal);
>extern void *__alloc_bootmem_core(struct bootmem_data *bdata,
>      unsigned long size,
>      unsigned long align,
>      unsigned long goal,
>      unsigned long limit);
># 76 "include/linux/bootmem.h"
>extern int reserve_bootmem(unsigned long addr, unsigned long size, int flags);
># 87 "include/linux/bootmem.h"
>extern unsigned long free_all_bootmem(void);
>extern unsigned long free_all_bootmem_node(pg_data_t *pgdat);
>extern void *__alloc_bootmem_node(pg_data_t *pgdat,
>      unsigned long size,
>      unsigned long align,
>      unsigned long goal);
>extern unsigned long init_bootmem_node(pg_data_t *pgdat,
>           unsigned long freepfn,
>           unsigned long startpfn,
>           unsigned long endpfn);
>extern void reserve_bootmem_node(pg_data_t *pgdat,
>     unsigned long physaddr,
>     unsigned long size,
>     int flags);
>extern void free_bootmem_node(pg_data_t *pgdat,
>         unsigned long addr,
>         unsigned long size);
>extern void *alloc_bootmem_section(unsigned long size,
>       unsigned long section_nr);
># 119 "include/linux/bootmem.h"
>static inline __attribute__((always_inline)) void *alloc_remap(int nid, unsigned long size)
>{
> return ((void *)0);
>}
>
>
>extern unsigned long __attribute__ ((__section__(".meminit.data"))) nr_kernel_pages;
>extern unsigned long __attribute__ ((__section__(".meminit.data"))) nr_all_pages;
>
>extern void *alloc_large_system_hash(const char *tablename,
>         unsigned long bucketsize,
>         unsigned long numentries,
>         int scale,
>         int flags,
>         unsigned int *_hash_shift,
>         unsigned int *_hash_mask,
>         unsigned long limit);
># 147 "include/linux/bootmem.h"
>extern int hashdist;
># 71 "kernel/sched.c" 2
>
># 1 "include/linux/debugfs.h" 1
># 22 "include/linux/debugfs.h"
>struct file_operations;
>
>struct debugfs_blob_wrapper {
> void *data;
> unsigned long size;
>};
># 79 "include/linux/debugfs.h"
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_file(const char *name, mode_t mode,
>     struct dentry *parent, void *data,
>     const struct file_operations *fops)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_dir(const char *name,
>      struct dentry *parent)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_symlink(const char *name,
>          struct dentry *parent,
>          const char *dest)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) void debugfs_remove(struct dentry *dentry)
>{ }
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
>                struct dentry *new_dir, char *new_name)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_u8(const char *name, mode_t mode,
>            struct dentry *parent,
>            u8 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_u16(const char *name, mode_t mode,
>      struct dentry *parent,
>      u16 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_u32(const char *name, mode_t mode,
>      struct dentry *parent,
>      u32 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_u64(const char *name, mode_t mode,
>      struct dentry *parent,
>      u64 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_x8(const char *name, mode_t mode,
>            struct dentry *parent,
>            u8 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_x16(const char *name, mode_t mode,
>      struct dentry *parent,
>      u16 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_x32(const char *name, mode_t mode,
>      struct dentry *parent,
>      u32 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_bool(const char *name, mode_t mode,
>       struct dentry *parent,
>       u32 *value)
>{
> return ERR_PTR(-19);
>}
>
>static inline __attribute__((always_inline)) struct dentry *debugfs_create_blob(const char *name, mode_t mode,
>      struct dentry *parent,
>      struct debugfs_blob_wrapper *blob)
>{
> return ERR_PTR(-19);
>}
># 72 "kernel/sched.c" 2
>
># 1 "include/linux/ctype.h" 1
># 18 "include/linux/ctype.h"
>extern unsigned char _ctype[];
># 37 "include/linux/ctype.h"
>static inline __attribute__((always_inline)) unsigned char __tolower(unsigned char c)
>{
> if ((((_ctype[(int)(unsigned char)(c)])&(0x01)) != 0))
>  c -= 'A'-'a';
> return c;
>}
>
>static inline __attribute__((always_inline)) unsigned char __toupper(unsigned char c)
>{
> if ((((_ctype[(int)(unsigned char)(c)])&(0x02)) != 0))
>  c -= 'a'-'A';
> return c;
>}
># 73 "kernel/sched.c" 2
>
>
># 1 "include/asm/tlb.h" 1
>
>
>
>
>
># 1 "include/linux/swap.h" 1
># 9 "include/linux/swap.h"
># 1 "include/linux/memcontrol.h" 1
># 23 "include/linux/memcontrol.h"
>struct mem_cgroup;
>struct page_cgroup;
>struct page;
>struct mm_struct;
># 75 "include/linux/memcontrol.h"
>static inline __attribute__((always_inline)) void page_reset_bad_cgroup(struct page *page)
>{
>}
>
>static inline __attribute__((always_inline)) struct page_cgroup *page_get_page_cgroup(struct page *page)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((always_inline)) int mem_cgroup_charge(struct page *page,
>     struct mm_struct *mm, gfp_t gfp_mask)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int mem_cgroup_cache_charge(struct page *page,
>     struct mm_struct *mm, gfp_t gfp_mask)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void mem_cgroup_uncharge_page(struct page *page)
>{
>}
>
>static inline __attribute__((always_inline)) void mem_cgroup_move_lists(struct page *page, bool active)
>{
>}
>
>static inline __attribute__((always_inline)) int mm_match_cgroup(struct mm_struct *mm, struct mem_cgroup *mem)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) int task_in_mem_cgroup(struct task_struct *task,
>         const struct mem_cgroup *mem)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) int mem_cgroup_prepare_migration(struct page *page)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void mem_cgroup_end_migration(struct page *page)
>{
>}
>
>static inline __attribute__((always_inline)) void
>mem_cgroup_page_migration(struct page *page, struct page *newpage)
>{
>}
>
>static inline __attribute__((always_inline)) int mem_cgroup_calc_mapped_ratio(struct mem_cgroup *mem)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int mem_cgroup_reclaim_imbalance(struct mem_cgroup *mem)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem,
>      int priority)
>{
>}
>
>static inline __attribute__((always_inline)) void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem,
>      int priority)
>{
>}
>
>static inline __attribute__((always_inline)) long mem_cgroup_calc_reclaim_active(struct mem_cgroup *mem,
>     struct zone *zone, int priority)
>{
> return 0;
>}
>
>static inline __attribute__((always_inline)) long mem_cgroup_calc_reclaim_inactive(struct mem_cgroup *mem,
>     struct zone *zone, int priority)
>{
> return 0;
>}
># 9 "include/linux/swap.h" 2
>
>
>
>
>
>struct notifier_block;
>
>struct bio;
>
>
>
>
>
>static inline __attribute__((always_inline)) int current_is_kswapd(void)
>{
> return (current_thread_info()->task)->flags & 0x00040000;
>}
># 57 "include/linux/swap.h"
>union swap_header {
> struct {
>  char reserved[((1UL) << 12) - 10];
>  char magic[10];
> } magic;
> struct {
>  char bootbits[1024];
>  __u32 version;
>  __u32 last_page;
>  __u32 nr_badpages;
>  unsigned char sws_uuid[16];
>  unsigned char sws_volume[16];
>  __u32 padding[117];
>  __u32 badpages[1];
> } info;
>};
>
>
>
>
>
>typedef struct {
> unsigned long val;
>} swp_entry_t;
>
>
>
>
>
>struct reclaim_state {
> unsigned long reclaimed_slab;
>};
>
>
>
>struct address_space;
>struct sysinfo;
>struct writeback_control;
>struct zone;
># 105 "include/linux/swap.h"
>struct swap_extent {
> struct list_head list;
> unsigned long start_page;
> unsigned long nr_pages;
> sector_t start_block;
>};
># 119 "include/linux/swap.h"
>enum {
> SWP_USED = (1 << 0),
> SWP_WRITEOK = (1 << 1),
> SWP_ACTIVE = (SWP_USED | SWP_WRITEOK),
>
> SWP_SCANNING = (1 << 8),
>};
># 135 "include/linux/swap.h"
>struct swap_info_struct {
> unsigned int flags;
> int prio;
> struct file *swap_file;
> struct block_device *bdev;
> struct list_head extent_list;
> struct swap_extent *curr_swap_extent;
> unsigned old_block_size;
> unsigned short * swap_map;
> unsigned int lowest_bit;
> unsigned int highest_bit;
> unsigned int cluster_next;
> unsigned int cluster_nr;
> unsigned int pages;
> unsigned int max;
> unsigned int inuse_pages;
> int next;
>};
>
>struct swap_list_t {
> int head;
> int next;
>};
>
>
>
>
>
>extern unsigned long totalram_pages;
>extern unsigned long totalreserve_pages;
>extern long nr_swap_pages;
>extern unsigned int nr_free_buffer_pages(void);
>extern unsigned int nr_free_pagecache_pages(void);
>
>
>
>
>
>
>extern void lru_cache_add(struct page *);
>extern void lru_cache_add_active(struct page *);
>extern void activate_page(struct page *);
>extern void mark_page_accessed(struct page *);
>extern void lru_add_drain(void);
>extern int lru_add_drain_all(void);
>extern void rotate_reclaimable_page(struct page *page);
>extern void swap_setup(void);
>
>
>extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
>     gfp_t gfp_mask);
>extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
>       gfp_t gfp_mask);
>extern int __isolate_lru_page(struct page *page, int mode);
>extern unsigned long shrink_all_memory(unsigned long nr_pages);
>extern int vm_swappiness;
>extern int remove_mapping(struct address_space *mapping, struct page *page);
>extern long vm_total_pages;
># 201 "include/linux/swap.h"
>static inline __attribute__((always_inline)) int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
>{
> return 0;
>}
>
>
>extern int kswapd_run(int nid);
>
>
>
>extern int shmem_unuse(swp_entry_t entry, struct page *page);
>
>
>extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
>
>
>
>extern int swap_readpage(struct file *, struct page *);
>extern int swap_writepage(struct page *page, struct writeback_control *wbc);
>extern void end_swap_bio_read(struct bio *bio, int err);
>
>
>extern struct address_space swapper_space;
>
>extern void show_swap_cache_info(void);
>extern int add_to_swap(struct page *, gfp_t);
>extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
>extern void __delete_from_swap_cache(struct page *);
>extern void delete_from_swap_cache(struct page *);
>extern void free_page_and_swap_cache(struct page *);
>extern void free_pages_and_swap_cache(struct page **, int);
>extern struct page *lookup_swap_cache(swp_entry_t);
>extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
>   struct vm_area_struct *vma, unsigned long addr);
>extern struct page *swapin_readahead(swp_entry_t, gfp_t,
>   struct vm_area_struct *vma, unsigned long addr);
>
>
>extern long total_swap_pages;
>extern unsigned int nr_swapfiles;
>extern void si_swapinfo(struct sysinfo *);
>extern swp_entry_t get_swap_page(void);
>extern swp_entry_t get_swap_page_of_type(int);
>extern int swap_duplicate(swp_entry_t);
>extern int valid_swaphandles(swp_entry_t, unsigned long *);
>extern void swap_free(swp_entry_t);
>extern void free_swap_and_cache(swp_entry_t);
>extern int swap_type_of(dev_t, sector_t, struct block_device **);
>extern unsigned int count_swap_pages(int, int);
>extern sector_t map_swap_page(struct swap_info_struct *, unsigned long);
>extern sector_t swapdev_block(int, unsigned long);
>extern struct swap_info_struct *get_swap_info_struct(unsigned);
>extern int can_share_swap_page(struct page *);
>extern int remove_exclusive_swap_page(struct page *);
>struct backing_dev_info;
>
>extern spinlock_t swap_lock;
>
>
>extern struct mm_struct * swap_token_mm;
>extern void grab_swap_token(void);
>extern void __put_swap_token(struct mm_struct *);
>
>static inline __attribute__((always_inline)) int has_swap_token(struct mm_struct *mm)
>{
> return (mm == swap_token_mm);
>}
>
>static inline __attribute__((always_inline)) void put_swap_token(struct mm_struct *mm)
>{
> if (has_swap_token(mm))
>  __put_swap_token(mm);
>}
>
>static inline __attribute__((always_inline)) void disable_swap_token(void)
>{
> put_swap_token(swap_token_mm);
>}
># 6 "include/asm/tlb.h" 2
>
>
># 1 "include/asm/pgalloc.h" 1
># 26 "include/asm/pgalloc.h"
>extern pgd_t *pgd_alloc(struct mm_struct *);
>extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
>
>extern pte_t *pte_alloc_one_kernel(struct mm_struct *, unsigned long);
>extern pgtable_t pte_alloc_one(struct mm_struct *, unsigned long);
>
>static inline __attribute__((always_inline)) void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
>{
> free_pages(((unsigned long) pte),0);
>}
>
>static inline __attribute__((always_inline)) void pte_free(struct mm_struct *mm, pgtable_t pte)
>{
> pgtable_page_dtor(pte);
> __free_pages((pte), 0);
>}
># 51 "include/asm/pgalloc.h"
>static inline __attribute__((always_inline)) void pmd_free(struct mm_struct *mm, pmd_t *pmd)
>{
> free_pages(((unsigned long)pmd),0);
>}
># 8 "include/asm/tlb.h" 2
>
># 1 "include/asm/tlbflush.h" 1
># 22 "include/asm/tlbflush.h"
>extern void flush_tlb_all(void);
>extern void flush_tlb_mm(struct mm_struct *mm);
>extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
>       unsigned long end);
>extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long address);
>extern void flush_tlb_kernel_vm(void);
>extern void flush_tlb_kernel_range(unsigned long start, unsigned long end);
>extern void __flush_tlb_one(unsigned long addr);
># 9 "include/asm/tlb.h" 2
># 17 "include/asm/tlb.h"
>struct mmu_gather {
> struct mm_struct *mm;
> unsigned int need_flush;
> unsigned long start;
> unsigned long end;
> unsigned int fullmm;
>};
>
>
>extern __typeof__(struct mmu_gather) per_cpu__mmu_gathers;
>
>static inline __attribute__((always_inline)) void __tlb_remove_tlb_entry(struct mmu_gather *tlb, pte_t *ptep,
>       unsigned long address)
>{
> if (tlb->start > address)
>  tlb->start = address;
> if (tlb->end < address + ((1UL) << 12))
>  tlb->end = address + ((1UL) << 12);
>}
>
>static inline __attribute__((always_inline)) void init_tlb_gather(struct mmu_gather *tlb)
>{
> tlb->need_flush = 0;
>
> tlb->start = (task_size);
> tlb->end = 0;
>
> if (tlb->fullmm) {
>  tlb->start = 0;
>  tlb->end = (task_size);
> }
>}
>
>
>
>
>static inline __attribute__((always_inline)) struct mmu_gather *
>tlb_gather_mmu(struct mm_struct *mm, unsigned int full_mm_flush)
>{
> struct mmu_gather *tlb = &(*({ extern int simple_identifier_mmu_gathers(void); do { } while (0); &per_cpu__mmu_gathers; }));
>
> tlb->mm = mm;
> tlb->fullmm = full_mm_flush;
>
> init_tlb_gather(tlb);
>
> return tlb;
>}
>
>extern void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
>          unsigned long end);
>
>static inline __attribute__((always_inline)) void
>tlb_flush_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
>{
> if (!tlb->need_flush)
>  return;
>
> flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end);
> init_tlb_gather(tlb);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
>{
> tlb_flush_mmu(tlb, start, end);
>
>
> do { } while (0);
>
> do { } while (0);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
>{
> tlb->need_flush = 1;
> free_page_and_swap_cache(page);
> return;
>}
># 75 "kernel/sched.c" 2
>
># 1 "include/asm/irq_regs.h" 1
># 76 "kernel/sched.c" 2
># 137 "kernel/sched.c"
>static inline __attribute__((always_inline)) int rt_policy(int policy)
>{
> if (__builtin_expect(!!(policy == 1 || policy == 2), 0))
>  return 1;
> return 0;
>}
>
>static inline __attribute__((always_inline)) int task_has_rt_policy(struct task_struct *p)
>{
> return rt_policy(p->policy);
>}
>
>
>
>
>struct rt_prio_array {
> unsigned long bitmap[(((100 +1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];
> struct list_head queue[100];
>};
>
>struct rt_bandwidth {
>
> spinlock_t rt_runtime_lock;
> ktime_t rt_period;
> u64 rt_runtime;
> struct hrtimer rt_period_timer;
>};
>
>static struct rt_bandwidth def_rt_bandwidth;
>
>static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
>
>static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
>{
> struct rt_bandwidth *rt_b =
>  ({ const typeof( ((struct rt_bandwidth *)0)->rt_period_timer ) *__mptr = (timer); (struct rt_bandwidth *)( (char *)__mptr - __builtin_offsetof(struct rt_bandwidth,rt_period_timer) );});
> ktime_t now;
> int overrun;
> int idle = 0;
>
> for (;;) {
>  now = hrtimer_cb_get_time(timer);
>  overrun = hrtimer_forward(timer, now, rt_b->rt_period);
>
>  if (!overrun)
>   break;
>
>  idle = do_sched_rt_period_timer(rt_b, overrun);
> }
>
> return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
>}
>
>static
>void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
>{
> rt_b->rt_period = ns_to_ktime(period);
> rt_b->rt_runtime = runtime;
>
> do { *(&rt_b->rt_runtime_lock) = (spinlock_t) { .raw_lock = { }, }; } while (0);
>
> hrtimer_init(&rt_b->rt_period_timer,
>   1, HRTIMER_MODE_REL);
> rt_b->rt_period_timer.function = sched_rt_period_timer;
> rt_b->rt_period_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
>}
>
>static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
>{
> ktime_t now;
>
> if (rt_b->rt_runtime == ((u64)~0ULL))
>  return;
>
> if (hrtimer_active(&rt_b->rt_period_timer))
>  return;
>
> do { do { } while (0); (void)0; (void)(&rt_b->rt_runtime_lock); } while (0);
> for (;;) {
>  if (hrtimer_active(&rt_b->rt_period_timer))
>   break;
>
>  now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
>  hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
>  hrtimer_start(&rt_b->rt_period_timer,
>         rt_b->rt_period_timer.expires,
>         HRTIMER_MODE_ABS);
> }
> do { do { } while (0); (void)0; (void)(&rt_b->rt_runtime_lock); } while (0);
>}
># 239 "kernel/sched.c"
>static struct mutex sched_domains_mutex = { .count = { (1) } , .wait_lock = (spinlock_t) { .raw_lock = { }, } , .wait_list = { &(sched_domains_mutex.wait_list), &(sched_domains_mutex.wait_list) } };
># 362 "kernel/sched.c"
>static inline __attribute__((always_inline)) void set_task_rq(struct task_struct *p, unsigned int cpu) { }
>
>
>
>
>struct cfs_rq {
> struct load_weight load;
> unsigned long nr_running;
>
> u64 exec_clock;
> u64 min_vruntime;
>
> struct rb_root tasks_timeline;
> struct rb_node *rb_leftmost;
>
> struct list_head tasks;
> struct list_head *balance_iterator;
>
>
>
>
>
> struct sched_entity *curr, *next;
>
> unsigned long nr_spread_over;
># 402 "kernel/sched.c"
>};
>
>
>struct rt_rq {
> struct rt_prio_array active;
> unsigned long rt_nr_running;
>
>
>
>
>
>
>
> int rt_throttled;
> u64 rt_time;
> u64 rt_runtime;
>
> spinlock_t rt_runtime_lock;
># 429 "kernel/sched.c"
>};
># 469 "kernel/sched.c"
>struct rq {
>
> spinlock_t lock;
>
>
>
>
>
> unsigned long nr_running;
>
> unsigned long cpu_load[5];
> unsigned char idle_at_tick;
>
> unsigned long last_tick_seen;
> unsigned char in_nohz_recently;
>
>
> struct load_weight load;
> unsigned long nr_load_updates;
> u64 nr_switches;
>
> struct cfs_rq cfs;
> struct rt_rq rt;
># 507 "kernel/sched.c"
> unsigned long nr_uninterruptible;
>
> struct task_struct *curr, *idle;
> unsigned long next_balance;
> struct mm_struct *prev_mm;
>
> u64 clock;
>
> atomic_t nr_iowait;
># 559 "kernel/sched.c"
> struct lock_class_key rq_lock_key;
>};
>
>static __typeof__(struct rq) per_cpu__runqueues;
>
>static inline __attribute__((always_inline)) void check_preempt_curr(struct rq *rq, struct task_struct *p)
>{
> rq->curr->sched_class->check_preempt_curr(rq, p);
>}
>
>static inline __attribute__((always_inline)) int cpu_of(struct rq *rq)
>{
>
>
>
> return 0;
>
>}
># 593 "kernel/sched.c"
>static inline __attribute__((always_inline)) void update_rq_clock(struct rq *rq)
>{
> rq->clock = sched_clock_cpu(cpu_of(rq));
>}
># 614 "kernel/sched.c"
>enum {
>
># 1 "kernel/sched_features.h" 1
>__SCHED_FEAT_NEW_FAIR_SLEEPERS ,
>__SCHED_FEAT_WAKEUP_PREEMPT ,
>__SCHED_FEAT_START_DEBIT ,
>__SCHED_FEAT_AFFINE_WAKEUPS ,
>__SCHED_FEAT_CACHE_HOT_BUDDY ,
>__SCHED_FEAT_SYNC_WAKEUPS ,
>__SCHED_FEAT_HRTICK ,
>__SCHED_FEAT_DOUBLE_TICK ,
>__SCHED_FEAT_NORMALIZED_SLEEPER ,
>__SCHED_FEAT_DEADLINE ,
># 616 "kernel/sched.c" 2
>};
>
>
>
>
>
>
> unsigned int sysctl_sched_features =
>
># 1 "kernel/sched_features.h" 1
>(1UL << __SCHED_FEAT_NEW_FAIR_SLEEPERS) * 1 |
>(1UL << __SCHED_FEAT_WAKEUP_PREEMPT) * 1 |
>(1UL << __SCHED_FEAT_START_DEBIT) * 1 |
>(1UL << __SCHED_FEAT_AFFINE_WAKEUPS) * 1 |
>(1UL << __SCHED_FEAT_CACHE_HOT_BUDDY) * 1 |
>(1UL << __SCHED_FEAT_SYNC_WAKEUPS) * 1 |
>(1UL << __SCHED_FEAT_HRTICK) * 1 |
>(1UL << __SCHED_FEAT_DOUBLE_TICK) * 0 |
>(1UL << __SCHED_FEAT_NORMALIZED_SLEEPER) * 1 |
>(1UL << __SCHED_FEAT_DEADLINE) * 1 |
># 625 "kernel/sched.c" 2
> 0;
>
>
>
>
>
>
>
>static char *sched_feat_names[] = {
>
># 1 "kernel/sched_features.h" 1
>"NEW_FAIR_SLEEPERS" ,
>"WAKEUP_PREEMPT" ,
>"START_DEBIT" ,
>"AFFINE_WAKEUPS" ,
>"CACHE_HOT_BUDDY" ,
>"SYNC_WAKEUPS" ,
>"HRTICK" ,
>"DOUBLE_TICK" ,
>"NORMALIZED_SLEEPER" ,
>"DEADLINE" ,
># 635 "kernel/sched.c" 2
> ((void *)0)
>};
>
>
>
>static int sched_feat_open(struct inode *inode, struct file *filp)
>{
> filp->private_data = inode->i_private;
> return 0;
>}
>
>static ssize_t
>sched_feat_read(struct file *filp, char *ubuf,
>  size_t cnt, loff_t *ppos)
>{
> char *buf;
> int r = 0;
> int len = 0;
> int i;
>
> for (i = 0; sched_feat_names[i]; i++) {
>  len += strlen(sched_feat_names[i]);
>  len += 4;
> }
>
> buf = kmalloc(len + 2, ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
> if (!buf)
>  return -12;
>
> for (i = 0; sched_feat_names[i]; i++) {
>  if (sysctl_sched_features & (1UL << i))
>   r += sprintf(buf + r, "%s ", sched_feat_names[i]);
>  else
>   r += sprintf(buf + r, "NO_%s ", sched_feat_names[i]);
> }
>
> r += sprintf(buf + r, "\n");
> ({ int __ret_warn_on = !!(r >= len + 2); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("kernel/sched.c", 672); __builtin_expect(!!(__ret_warn_on), 0); });
>
> r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
>
> kfree(buf);
>
> return r;
>}
>
>static ssize_t
>sched_feat_write(struct file *filp, const char *ubuf,
>  size_t cnt, loff_t *ppos)
>{
> char buf[64];
> char *cmp = buf;
> int neg = 0;
> int i;
>
> if (cnt > 63)
>  cnt = 63;
>
> if (copy_from_user(&buf, ubuf, cnt))
>  return -14;
>
> buf[cnt] = 0;
>
> if (strncmp(buf, "NO_", 3) == 0) {
>  neg = 1;
>  cmp += 3;
> }
>
> for (i = 0; sched_feat_names[i]; i++) {
>  int len = strlen(sched_feat_names[i]);
>
>  if (strncmp(cmp, sched_feat_names[i], len) == 0) {
>   if (neg)
>    sysctl_sched_features &= ~(1UL << i);
>   else
>    sysctl_sched_features |= (1UL << i);
>   break;
>  }
> }
>
> if (!sched_feat_names[i])
>  return -22;
>
> filp->f_pos += cnt;
>
> return cnt;
>}
>
>static struct file_operations sched_feat_fops = {
> .open = sched_feat_open,
> .read = sched_feat_read,
> .write = sched_feat_write,
>};
>
>static __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) int sched_init_debug(void)
>{
> debugfs_create_file("sched_features", 0644, ((void *)0), ((void *)0),
>   &sched_feat_fops);
>
> return 0;
>}
>static initcall_t __initcall_sched_init_debug7 __attribute__((__used__)) __attribute__((__section__(".initcall" "7" ".init"))) = sched_init_debug;
># 746 "kernel/sched.c"
> unsigned int sysctl_sched_nr_migrate = 32;
>
>
>
>
>
>unsigned int sysctl_sched_rt_period = 1000000;
>
>static int scheduler_running;
>
>
>
>
>
>int sysctl_sched_rt_runtime = 950000;
>
>static inline __attribute__((always_inline)) u64 global_rt_period(void)
>{
> return (u64)sysctl_sched_rt_period * 1000L;
>}
>
>static inline __attribute__((always_inline)) u64 global_rt_runtime(void)
>{
> if (sysctl_sched_rt_period < 0)
>  return ((u64)~0ULL);
>
> return (u64)sysctl_sched_rt_runtime * 1000L;
>}
>
>unsigned long long time_sync_thresh = 100000;
>
>static __typeof__(unsigned long long) per_cpu__time_offset;
>static __typeof__(unsigned long long) per_cpu__prev_cpu_time;
>
>
>
>
>
>
>
>static spinlock_t time_sync_lock = (spinlock_t) { .raw_lock = { }, };
>static unsigned long long prev_global_time;
>
>static unsigned long long __sync_cpu_clock(unsigned long long time, int cpu)
>{
>
>
>
>
> do { } while (0);
> do { (void)(&time_sync_lock.raw_lock); } while (0);
>
> if (time < prev_global_time) {
>  (*((void)(cpu), &per_cpu__time_offset)) += prev_global_time - time;
>  time = prev_global_time;
> } else {
>  prev_global_time = time;
> }
>
> do { (void)(&time_sync_lock.raw_lock); } while (0);
> do { } while (0);
>
> return time;
>}
>
>static unsigned long long __cpu_clock(int cpu)
>{
> unsigned long long now;
>
>
>
>
>
> if (__builtin_expect(!!(!scheduler_running), 0))
>  return 0;
>
> now = sched_clock_cpu(cpu);
>
> return now;
>}
>
>
>
>
>
>unsigned long long cpu_clock(int cpu)
>{
> unsigned long long prev_cpu_time, time, delta_time;
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0);
> prev_cpu_time = (*((void)(cpu), &per_cpu__prev_cpu_time));
> time = __cpu_clock(cpu) + (*((void)(cpu), &per_cpu__time_offset));
> delta_time = time-prev_cpu_time;
>
> if (__builtin_expect(!!(delta_time > time_sync_thresh), 0)) {
>  time = __sync_cpu_clock(time, cpu);
>  (*((void)(cpu), &per_cpu__prev_cpu_time)) = time;
> }
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0);
>
> return time;
>}
>extern typeof(cpu_clock) cpu_clock; static const char __kstrtab_cpu_clock[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "cpu_clock"; static const struct kernel_symbol __ksymtab_cpu_clock __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&cpu_clock, __kstrtab_cpu_clock };
># 858 "kernel/sched.c"
>static inline __attribute__((always_inline)) int task_current(struct rq *rq, struct task_struct *p)
>{
> return rq->curr == p;
>}
>
>
>static inline __attribute__((always_inline)) int task_running(struct rq *rq, struct task_struct *p)
>{
> return task_current(rq, p);
>}
>
>static inline __attribute__((always_inline)) void prepare_lock_switch(struct rq *rq, struct task_struct *next)
>{
>}
>
>static inline __attribute__((always_inline)) void finish_lock_switch(struct rq *rq, struct task_struct *prev)
>{
># 884 "kernel/sched.c"
> do { } while (0);
>
> do { unblock_signals(); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
>}
># 937 "kernel/sched.c"
>static inline __attribute__((always_inline)) struct rq *__task_rq_lock(struct task_struct *p)
>
>{
> for (;;) {
>  struct rq *rq = (&(*((void)((task_cpu(p))), &per_cpu__runqueues)));
>  do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
>  if (__builtin_expect(!!(rq == (&(*((void)((task_cpu(p))), &per_cpu__runqueues)))), 1))
>   return rq;
>  do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
> }
>}
>
>
>
>
>
>
>static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
>
>{
> struct rq *rq;
>
> for (;;) {
>  do { do { ({ unsigned long __dummy; typeof(*flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (*flags) = get_signals(); } while(0); block_signals(); } while(0);
>  rq = (&(*((void)((task_cpu(p))), &per_cpu__runqueues)));
>  do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
>  if (__builtin_expect(!!(rq == (&(*((void)((task_cpu(p))), &per_cpu__runqueues)))), 1))
>   return rq;
>  do { do { ({ unsigned long __dummy; typeof(*flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(*flags); } while(0); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
> }
>}
>
>static void __task_rq_unlock(struct rq *rq)
>
>{
> do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
>}
>
>static inline __attribute__((always_inline)) void task_rq_unlock(struct rq *rq, unsigned long *flags)
>
>{
> do { do { ({ unsigned long __dummy; typeof(*flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(*flags); } while(0); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
>}
>
>
>
>
>static struct rq *this_rq_lock(void)
>
>{
> struct rq *rq;
>
> block_signals();
> rq = (&per_cpu__runqueues);
> do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
>
> return rq;
>}
>
>static void __resched_task(struct task_struct *p, int tif_bit);
>
>static inline __attribute__((always_inline)) void resched_task(struct task_struct *p)
>{
> __resched_task(p, 2);
>}
># 1205 "kernel/sched.c"
>static inline __attribute__((always_inline)) void hrtick_clear(struct rq *rq)
>{
>}
>
>static inline __attribute__((always_inline)) void hrtick_set(struct rq *rq)
>{
>}
>
>static inline __attribute__((always_inline)) void init_rq_hrtick(struct rq *rq)
>{
>}
>
>void hrtick_resched(void)
>{
>}
>
>static inline __attribute__((always_inline)) void init_hrtick(void)
>{
>}
># 1314 "kernel/sched.c"
>static void __resched_task(struct task_struct *p, int tif_bit)
>{
> do { (void)(&(&(*((void)((task_cpu(p))), &per_cpu__runqueues)))->lock); } while (0);
> set_tsk_thread_flag(p, tif_bit);
>}
># 1334 "kernel/sched.c"
>static unsigned long
>calc_delta_mine(unsigned long delta_exec, unsigned long weight,
>  struct load_weight *lw)
>{
> u64 tmp;
>
> if (!lw->inv_weight)
>  lw->inv_weight = 1 + ((1UL << 32)-lw->weight/2)/(lw->weight+1);
>
> tmp = (u64)delta_exec * weight;
>
>
>
> if (__builtin_expect(!!(tmp > (1UL << 32)), 0))
>  tmp = ((((((tmp) + (1UL << ((32/2) - 1))) >> (32/2)) * lw->inv_weight) + (1UL << ((32/2) - 1))) >> (32/2));
>
> else
>  tmp = (((tmp * lw->inv_weight) + (1UL << ((32) - 1))) >> (32));
>
> return (unsigned long)({ typeof(tmp) _min1 = (tmp); typeof((u64)(unsigned long)((long)(~0UL>>1))) _min2 = ((u64)(unsigned long)((long)(~0UL>>1))); (void) (&_min1 == &_min2); _min1 < _min2 ? _min1 : _min2; });
>}
>
>static inline __attribute__((always_inline)) unsigned long
>calc_delta_fair(unsigned long delta_exec, struct load_weight *lw)
>{
> return calc_delta_mine(delta_exec, (1L << 10), lw);
>}
>
>static inline __attribute__((always_inline)) void update_load_add(struct load_weight *lw, unsigned long inc)
>{
> lw->weight += inc;
> lw->inv_weight = 0;
>}
>
>static inline __attribute__((always_inline)) void update_load_sub(struct load_weight *lw, unsigned long dec)
>{
> lw->weight -= dec;
> lw->inv_weight = 0;
>}
># 1398 "kernel/sched.c"
>static const int prio_to_weight[40] = {
>               88761, 71755, 56483, 46273, 36291,
>               29154, 23254, 18705, 14949, 11916,
>                9548, 7620, 6100, 4904, 3906,
>                3121, 2501, 1991, 1586, 1277,
>                1024, 820, 655, 526, 423,
>                 335, 272, 215, 172, 137,
>                 110, 87, 70, 56, 45,
>                  36, 29, 23, 18, 15,
>};
># 1416 "kernel/sched.c"
>static const u32 prio_to_wmult[40] = {
>               48388, 59856, 76040, 92818, 118348,
>              147320, 184698, 229616, 287308, 360437,
>              449829, 563644, 704093, 875809, 1099582,
>             1376151, 1717300, 2157191, 2708050, 3363326,
>             4194304, 5237765, 6557202, 8165337, 10153587,
>            12820798, 15790321, 19976592, 24970740, 31350126,
>            39045157, 49367440, 61356676, 76695844, 95443717,
>           119304647, 148102320, 186737708, 238609294, 286331153,
>};
>
>static void activate_task(struct rq *rq, struct task_struct *p, int wakeup);
>
>
>
>
>
>
>struct rq_iterator {
> void *arg;
> struct task_struct *(*start)(void *);
> struct task_struct *(*next)(void *);
>};
># 1456 "kernel/sched.c"
>static inline __attribute__((always_inline)) void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
>
>
>static inline __attribute__((always_inline)) void inc_cpu_load(struct rq *rq, unsigned long load)
>{
> update_load_add(&rq->load, load);
>}
>
>static inline __attribute__((always_inline)) void dec_cpu_load(struct rq *rq, unsigned long load)
>{
> update_load_sub(&rq->load, load);
>}
># 1484 "kernel/sched.c"
>
># 1 "kernel/sched_stats.h" 1
># 125 "kernel/sched_stats.h"
>static inline __attribute__((always_inline)) void
>rq_sched_info_arrive(struct rq *rq, unsigned long long delta)
>{}
>static inline __attribute__((always_inline)) void
>rq_sched_info_depart(struct rq *rq, unsigned long long delta)
>{}
># 1485 "kernel/sched.c" 2
>
># 1 "kernel/sched_idletask.c" 1
># 17 "kernel/sched_idletask.c"
>static void check_preempt_curr_idle(struct rq *rq, struct task_struct *p)
>{
> resched_task(rq->idle);
>}
>
>static struct task_struct *pick_next_task_idle(struct rq *rq)
>{
> do { } while (0);
>
> return rq->idle;
>}
>
>
>
>
>
>static void
>dequeue_task_idle(struct rq *rq, struct task_struct *p, int sleep)
>{
> do { unblock_signals(); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
> printk("<3>" "bad: scheduling from the idle thread!\n");
> dump_stack();
> do { block_signals(); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
>}
>
>static void put_prev_task_idle(struct rq *rq, struct task_struct *prev)
>{
>}
># 64 "kernel/sched_idletask.c"
>static void task_tick_idle(struct rq *rq, struct task_struct *curr, int queued)
>{
>}
>
>static void set_curr_task_idle(struct rq *rq)
>{
>}
>
>static void switched_to_idle(struct rq *rq, struct task_struct *p,
>        int running)
>{
>
> if (running)
>  resched_task(rq->curr);
> else
>  check_preempt_curr(rq, p);
>}
>
>static void prio_changed_idle(struct rq *rq, struct task_struct *p,
>         int oldprio, int running)
>{
>
>
>
>
>
>
>
> if (running) {
>  if (p->prio > oldprio)
>   resched_task(rq->curr);
> } else
>  check_preempt_curr(rq, p);
>}
>
>
>
>
>static const struct sched_class idle_sched_class = {
>
>
>
>
> .dequeue_task = dequeue_task_idle,
>
>
>
>
> .check_preempt_curr = check_preempt_curr_idle,
>
> .pick_next_task = pick_next_task_idle,
> .put_prev_task = put_prev_task_idle,
>
>
>
>
>
>
> .set_curr_task = set_curr_task_idle,
> .task_tick = task_tick_idle,
>
> .prio_changed = prio_changed_idle,
> .switched_to = switched_to_idle,
>
>
>};
># 1486 "kernel/sched.c" 2
>
># 1 "kernel/sched_fair.c" 1
># 37 "kernel/sched_fair.c"
>unsigned int sysctl_sched_latency = 20000000ULL;
>
>
>
>
>
>unsigned int sysctl_sched_min_granularity = 4000000ULL;
>
>
>
>
>static unsigned int sched_nr_latency = 5;
>
>
>
>
>
> unsigned int sysctl_sched_child_runs_first = 1;
>
>
>
>
>
>
>
>unsigned int sysctl_sched_compat_yield;
># 72 "kernel/sched_fair.c"
>unsigned int sysctl_sched_wakeup_granularity = 10000000UL;
>
> unsigned int sysctl_sched_migration_cost = 500000UL;
>
>
>
>
>
>static inline __attribute__((always_inline)) struct task_struct *task_of(struct sched_entity *se)
>{
> return ({ const typeof( ((struct task_struct *)0)->se ) *__mptr = (se); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,se) );});
>}
># 146 "kernel/sched_fair.c"
>static inline __attribute__((always_inline)) struct rq *rq_of(struct cfs_rq *cfs_rq)
>{
> return ({ const typeof( ((struct rq *)0)->cfs ) *__mptr = (cfs_rq); (struct rq *)( (char *)__mptr - __builtin_offsetof(struct rq,cfs) );});
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) struct cfs_rq *task_cfs_rq(struct task_struct *p)
>{
> return &(&(*((void)((task_cpu(p))), &per_cpu__runqueues)))->cfs;
>}
>
>static inline __attribute__((always_inline)) struct cfs_rq *cfs_rq_of(struct sched_entity *se)
>{
> struct task_struct *p = task_of(se);
> struct rq *rq = (&(*((void)((task_cpu(p))), &per_cpu__runqueues)));
>
> return &rq->cfs;
>}
>
>
>static inline __attribute__((always_inline)) struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((always_inline)) struct cfs_rq *cpu_cfs_rq(struct cfs_rq *cfs_rq, int this_cpu)
>{
> return &(&(*((void)((this_cpu)), &per_cpu__runqueues)))->cfs;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int
>is_same_group(struct sched_entity *se, struct sched_entity *pse)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) struct sched_entity *parent_entity(struct sched_entity *se)
>{
> return ((void *)0);
>}
># 201 "kernel/sched_fair.c"
>static inline __attribute__((always_inline)) u64 max_vruntime(u64 min_vruntime, u64 vruntime)
>{
> s64 delta = (s64)(vruntime - min_vruntime);
> if (delta > 0)
>  min_vruntime = vruntime;
>
> return min_vruntime;
>}
>
>static inline __attribute__((always_inline)) u64 min_vruntime(u64 min_vruntime, u64 vruntime)
>{
> s64 delta = (s64)(vruntime - min_vruntime);
> if (delta < 0)
>  min_vruntime = vruntime;
>
> return min_vruntime;
>}
>
>static inline __attribute__((always_inline)) s64 entity_key(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> return se->vruntime - cfs_rq->min_vruntime;
>}
>
>
>
>
>static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> struct rb_node **link = &cfs_rq->tasks_timeline.rb_node;
> struct rb_node *parent = ((void *)0);
> struct sched_entity *entry;
> s64 key = entity_key(cfs_rq, se);
> int leftmost = 1;
>
>
>
>
> while (*link) {
>  parent = *link;
>  entry = ({ const typeof( ((struct sched_entity *)0)->run_node ) *__mptr = (parent); (struct sched_entity *)( (char *)__mptr - __builtin_offsetof(struct sched_entity,run_node) );});
>
>
>
>
>  if (key < entity_key(cfs_rq, entry)) {
>   link = &parent->rb_left;
>  } else {
>   link = &parent->rb_right;
>   leftmost = 0;
>  }
> }
>
>
>
>
>
> if (leftmost) {
>  cfs_rq->rb_leftmost = &se->run_node;
>
>
>
>
>  cfs_rq->min_vruntime =
>   max_vruntime(cfs_rq->min_vruntime, se->vruntime);
> }
>
> rb_link_node(&se->run_node, parent, link);
> rb_insert_color(&se->run_node, &cfs_rq->tasks_timeline);
>}
>
>static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> if (cfs_rq->rb_leftmost == &se->run_node) {
>  struct rb_node *next_node;
>  struct sched_entity *next;
>
>  next_node = rb_next(&se->run_node);
>  cfs_rq->rb_leftmost = next_node;
>
>  if (next_node) {
>   next = ({ const typeof( ((struct sched_entity *)0)->run_node ) *__mptr = (next_node); (struct sched_entity *)( (char *)__mptr - __builtin_offsetof(struct sched_entity,run_node) );});
>
>   cfs_rq->min_vruntime =
>    max_vruntime(cfs_rq->min_vruntime,
>          next->vruntime);
>  }
> }
>
> if (cfs_rq->next == se)
>  cfs_rq->next = ((void *)0);
>
> rb_erase(&se->run_node, &cfs_rq->tasks_timeline);
>}
>
>static inline __attribute__((always_inline)) struct rb_node *first_fair(struct cfs_rq *cfs_rq)
>{
> return cfs_rq->rb_leftmost;
>}
>
>static struct sched_entity *__pick_next_entity(struct cfs_rq *cfs_rq)
>{
> return ({ const typeof( ((struct sched_entity *)0)->run_node ) *__mptr = (first_fair(cfs_rq)); (struct sched_entity *)( (char *)__mptr - __builtin_offsetof(struct sched_entity,run_node) );});
>}
>
>static inline __attribute__((always_inline)) struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
>{
> struct rb_node *last = rb_last(&cfs_rq->tasks_timeline);
>
> if (!last)
>  return ((void *)0);
>
> return ({ const typeof( ((struct sched_entity *)0)->run_node ) *__mptr = (last); (struct sched_entity *)( (char *)__mptr - __builtin_offsetof(struct sched_entity,run_node) );});
>}
>
>
>
>
>
>
>int sched_nr_latency_handler(struct ctl_table *table, int write,
>  struct file *filp, void *buffer, size_t *lenp,
>  loff_t *ppos)
>{
> int ret = proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos);
>
> if (ret || !write)
>  return ret;
>
> sched_nr_latency = (((sysctl_sched_latency) + (sysctl_sched_min_granularity) - 1) / (sysctl_sched_min_granularity));
>
>
> return 0;
>}
># 344 "kernel/sched_fair.c"
>static u64 __sched_period(unsigned long nr_running)
>{
> u64 period = sysctl_sched_latency;
> unsigned long nr_latency = sched_nr_latency;
>
> if (__builtin_expect(!!(nr_running > nr_latency), 0)) {
>  period = sysctl_sched_min_granularity;
>  period *= nr_running;
> }
>
> return period;
>}
>
>
>
>
>
>
>
>static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> u64 slice = __sched_period(cfs_rq->nr_running);
>
> for (; se; se = ((void *)0)) {
>  cfs_rq = cfs_rq_of(se);
>
>  slice *= se->load.weight;
>  ({ uint32_t __base = (cfs_rq->load.weight); uint32_t __rem; __rem = ((uint64_t)(slice)) % __base; (slice) = ((uint64_t)(slice)) / __base; __rem; });
> }
>
>
> return slice;
>}
>
>
>
>
>
>
>static u64 sched_vslice_add(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> unsigned long nr_running = cfs_rq->nr_running;
> unsigned long weight;
> u64 vslice;
>
> if (!se->on_rq)
>  nr_running++;
>
> vslice = __sched_period(nr_running);
>
> for (; se; se = ((void *)0)) {
>  cfs_rq = cfs_rq_of(se);
>
>  weight = cfs_rq->load.weight;
>  if (!se->on_rq)
>   weight += se->load.weight;
>
>  vslice *= (1L << 10);
>  ({ uint32_t __base = (weight); uint32_t __rem; __rem = ((uint64_t)(vslice)) % __base; (vslice) = ((uint64_t)(vslice)) / __base; __rem; });
> }
>
> return vslice;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>__update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
>       unsigned long delta_exec)
>{
> unsigned long delta_exec_weighted;
>
> do { } while (0);
>
> curr->sum_exec_runtime += delta_exec;
> do { } while (0);
> delta_exec_weighted = delta_exec;
> if (__builtin_expect(!!(curr->load.weight != (1L << 10)), 0)) {
>  delta_exec_weighted = calc_delta_fair(delta_exec_weighted,
>       &curr->load);
> }
> curr->vruntime += delta_exec_weighted;
>}
>
>static void update_curr(struct cfs_rq *cfs_rq)
>{
> struct sched_entity *curr = cfs_rq->curr;
> u64 now = rq_of(cfs_rq)->clock;
> unsigned long delta_exec;
>
> if (__builtin_expect(!!(!curr), 0))
>  return;
>
>
>
>
>
>
> delta_exec = (unsigned long)(now - curr->exec_start);
>
> __update_curr(cfs_rq, curr, delta_exec);
> curr->exec_start = now;
>
> if (1) {
>  struct task_struct *curtask = task_of(curr);
>
>  cpuacct_charge(curtask, delta_exec);
> }
>}
>
>static inline __attribute__((always_inline)) void
>update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> do { } while (0);
>}
>
>
>
>
>static void update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
>
>
>
>
> if (se != cfs_rq->curr)
>  update_stats_wait_start(cfs_rq, se);
>}
>
>static void
>update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> do { } while (0);
>
> do { } while (0);
> do { } while (0);
>
> do { } while (0);
>}
>
>static inline __attribute__((always_inline)) void
>update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
>
>
>
>
> if (se != cfs_rq->curr)
>  update_stats_wait_end(cfs_rq, se);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void
>update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
>
>
>
> se->exec_start = rq_of(cfs_rq)->clock;
>}
>
>
>
>
>
>static void
>account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> update_load_add(&cfs_rq->load, se->load.weight);
> cfs_rq->nr_running++;
> se->on_rq = 1;
> list_add(&se->group_node, &cfs_rq->tasks);
>}
>
>static void
>account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> update_load_sub(&cfs_rq->load, se->load.weight);
> cfs_rq->nr_running--;
> se->on_rq = 0;
> list_del_init(&se->group_node);
>}
>
>static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
># 575 "kernel/sched_fair.c"
>}
>
>static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
>
> s64 d = se->vruntime - cfs_rq->min_vruntime;
>
> if (d < 0)
>  d = -d;
>
> if (d > 3*sysctl_sched_latency)
>  do { } while (0);
>
>}
>
>static void
>place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
>{
> u64 vruntime;
>
> if (first_fair(cfs_rq)) {
>  vruntime = min_vruntime(cfs_rq->min_vruntime,
>    __pick_next_entity(cfs_rq)->vruntime);
> } else
>  vruntime = cfs_rq->min_vruntime;
>
>
>
>
>
>
>
> if (initial && (sysctl_sched_features & (1UL << __SCHED_FEAT_START_DEBIT)))
>  vruntime += sched_vslice_add(cfs_rq, se);
>
> if (!initial) {
>
>  if ((sysctl_sched_features & (1UL << __SCHED_FEAT_NEW_FAIR_SLEEPERS)))
>   vruntime -= sysctl_sched_latency;
>
>
>  vruntime = max_vruntime(se->vruntime, vruntime);
> }
>
> se->vruntime = vruntime;
>}
>
>static void
>enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int wakeup)
>{
>
>
>
> update_curr(cfs_rq);
> account_entity_enqueue(cfs_rq, se);
>
> if (wakeup) {
>  place_entity(cfs_rq, se, 0);
>  enqueue_sleeper(cfs_rq, se);
> }
>
> update_stats_enqueue(cfs_rq, se);
> check_spread(cfs_rq, se);
> if (se != cfs_rq->curr)
>  __enqueue_entity(cfs_rq, se);
>}
>
>static void update_avg(u64 *avg, u64 sample)
>{
> s64 diff = sample - *avg;
> *avg += diff >> 3;
>}
>
>static void update_avg_stats(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> if (!se->last_wakeup)
>  return;
>
> update_avg(&se->avg_overlap, se->sum_exec_runtime - se->last_wakeup);
> se->last_wakeup = 0;
>}
>
>static void
>dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
>{
>
>
>
> update_curr(cfs_rq);
>
> update_stats_dequeue(cfs_rq, se);
> if (sleep) {
>  update_avg_stats(cfs_rq, se);
># 678 "kernel/sched_fair.c"
> }
>
> if (se != cfs_rq->curr)
>  __dequeue_entity(cfs_rq, se);
> account_entity_dequeue(cfs_rq, se);
>}
>
>
>
>
>static void
>check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
>{
> unsigned long ideal_runtime, delta_exec;
>
> ideal_runtime = sched_slice(cfs_rq, curr);
> delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
> if (delta_exec > ideal_runtime)
>  resched_task(rq_of(cfs_rq)->curr);
>}
>
>static void
>set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
>
> if (se->on_rq) {
>
>
>
>
>
>  update_stats_wait_end(cfs_rq, se);
>  __dequeue_entity(cfs_rq, se);
> }
>
> update_stats_curr_start(cfs_rq, se);
> cfs_rq->curr = se;
># 726 "kernel/sched_fair.c"
> se->prev_sum_exec_runtime = se->sum_exec_runtime;
>}
>
>static int
>wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se);
>
>static struct sched_entity *
>pick_next(struct cfs_rq *cfs_rq, struct sched_entity *se)
>{
> if (!cfs_rq->next)
>  return se;
>
> if (wakeup_preempt_entity(cfs_rq->next, se) != 0)
>  return se;
>
> return cfs_rq->next;
>}
>
>static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq)
>{
> struct sched_entity *se = ((void *)0);
>
> if (first_fair(cfs_rq)) {
>  se = __pick_next_entity(cfs_rq);
>  se = pick_next(cfs_rq, se);
>  set_next_entity(cfs_rq, se);
> }
>
> return se;
>}
>
>static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
>{
>
>
>
>
> if (prev->on_rq)
>  update_curr(cfs_rq);
>
> check_spread(cfs_rq, prev);
> if (prev->on_rq) {
>  update_stats_wait_start(cfs_rq, prev);
>
>  __enqueue_entity(cfs_rq, prev);
> }
> cfs_rq->curr = ((void *)0);
>}
>
>static void
>entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
>{
>
>
>
> update_curr(cfs_rq);
># 800 "kernel/sched_fair.c"
> if (cfs_rq->nr_running > 1 || !(sysctl_sched_features & (1UL << __SCHED_FEAT_WAKEUP_PREEMPT)))
>  check_preempt_tick(cfs_rq, curr);
>}
># 839 "kernel/sched_fair.c"
>static inline __attribute__((always_inline)) void
>hrtick_start_fair(struct rq *rq, struct task_struct *p)
>{
>}
>
>
>
>
>
>
>
>static void enqueue_task_fair(struct rq *rq, struct task_struct *p, int wakeup)
>{
> struct cfs_rq *cfs_rq;
> struct sched_entity *se = &p->se;
>
> for (; se; se = ((void *)0)) {
>  if (se->on_rq)
>   break;
>  cfs_rq = cfs_rq_of(se);
>  enqueue_entity(cfs_rq, se, wakeup);
>  wakeup = 1;
> }
>
> hrtick_start_fair(rq, rq->curr);
>}
>
>
>
>
>
>
>static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int sleep)
>{
> struct cfs_rq *cfs_rq;
> struct sched_entity *se = &p->se;
>
> for (; se; se = ((void *)0)) {
>  cfs_rq = cfs_rq_of(se);
>  dequeue_entity(cfs_rq, se, sleep);
>
>  if (cfs_rq->load.weight)
>   break;
>  sleep = 1;
> }
>
> hrtick_start_fair(rq, rq->curr);
>}
>
>
>
>
>
>
>static void yield_task_fair(struct rq *rq)
>{
> struct task_struct *curr = rq->curr;
> struct cfs_rq *cfs_rq = task_cfs_rq(curr);
> struct sched_entity *rightmost, *se = &curr->se;
>
>
>
>
> if (__builtin_expect(!!(cfs_rq->nr_running == 1), 0))
>  return;
>
> if (__builtin_expect(!!(!sysctl_sched_compat_yield), 1) && curr->policy != 3) {
>  update_rq_clock(rq);
>
>
>
>  update_curr(cfs_rq);
>
>  return;
> }
>
>
>
> rightmost = __pick_last_entity(cfs_rq);
>
>
>
> if (__builtin_expect(!!(!rightmost || rightmost->vruntime < se->vruntime), 0))
>  return;
>
>
>
>
>
>
> se->vruntime = rightmost->vruntime + 1;
>}
># 980 "kernel/sched_fair.c"
>static inline __attribute__((always_inline)) int wake_idle(int cpu, struct task_struct *p)
>{
> return cpu;
>}
># 1109 "kernel/sched_fair.c"
>static unsigned long wakeup_gran(struct sched_entity *se)
>{
> unsigned long gran = sysctl_sched_wakeup_granularity;
>
>
>
>
>
> if (__builtin_expect(!!(se->load.weight > (1L << 10)), 0))
>  gran = calc_delta_fair(gran, &se->load);
>
> return gran;
>}
># 1137 "kernel/sched_fair.c"
>static int
>wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
>{
> s64 gran, vdiff = curr->vruntime - se->vruntime;
>
> if (vdiff < 0)
>  return -1;
>
> gran = wakeup_gran(curr);
> if (vdiff > gran)
>  return 1;
>
> return 0;
>}
>
>
>static inline __attribute__((always_inline)) int depth_se(struct sched_entity *se)
>{
> int depth = 0;
>
> for (; se; se = ((void *)0))
>  depth++;
>
> return depth;
>}
>
>
>
>
>static void check_preempt_wakeup(struct rq *rq, struct task_struct *p)
>{
> struct task_struct *curr = rq->curr;
> struct cfs_rq *cfs_rq = task_cfs_rq(curr);
> struct sched_entity *se = &curr->se, *pse = &p->se;
> int se_depth, pse_depth;
>
> if (__builtin_expect(!!(rt_prio(p->prio)), 0)) {
>  update_rq_clock(rq);
>  update_curr(cfs_rq);
>  resched_task(curr);
>  return;
> }
>
> se->last_wakeup = se->sum_exec_runtime;
> if (__builtin_expect(!!(se == pse), 0))
>  return;
>
> cfs_rq_of(pse)->next = pse;
>
>
>
>
>
> if (__builtin_expect(!!(p->policy == 3), 0))
>  return;
>
> if (!(sysctl_sched_features & (1UL << __SCHED_FEAT_WAKEUP_PREEMPT)))
>  return;
># 1204 "kernel/sched_fair.c"
> se_depth = depth_se(se);
> pse_depth = depth_se(pse);
>
> while (se_depth > pse_depth) {
>  se_depth--;
>  se = parent_entity(se);
> }
>
> while (pse_depth > se_depth) {
>  pse_depth--;
>  pse = parent_entity(pse);
> }
>
> while (!is_same_group(se, pse)) {
>  se = parent_entity(se);
>  pse = parent_entity(pse);
> }
>
> if (wakeup_preempt_entity(se, pse) == 1)
>  resched_task(curr);
>}
>
>static struct task_struct *pick_next_task_fair(struct rq *rq)
>{
> struct task_struct *p;
> struct cfs_rq *cfs_rq = &rq->cfs;
> struct sched_entity *se;
>
> if (__builtin_expect(!!(!cfs_rq->nr_running), 0))
>  return ((void *)0);
>
> do {
>  se = pick_next_entity(cfs_rq);
>  cfs_rq = group_cfs_rq(se);
> } while (cfs_rq);
>
> p = task_of(se);
> hrtick_start_fair(rq, p);
>
> return p;
>}
>
>
>
>
>static void put_prev_task_fair(struct rq *rq, struct task_struct *prev)
>{
> struct sched_entity *se = &prev->se;
> struct cfs_rq *cfs_rq;
>
> for (; se; se = ((void *)0)) {
>  cfs_rq = cfs_rq_of(se);
>  put_prev_entity(cfs_rq, se);
> }
>}
># 1410 "kernel/sched_fair.c"
>static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
>{
> struct cfs_rq *cfs_rq;
> struct sched_entity *se = &curr->se;
>
> for (; se; se = ((void *)0)) {
>  cfs_rq = cfs_rq_of(se);
>  entity_tick(cfs_rq, se, queued);
> }
>}
># 1430 "kernel/sched_fair.c"
>static void task_new_fair(struct rq *rq, struct task_struct *p)
>{
> struct cfs_rq *cfs_rq = task_cfs_rq(p);
> struct sched_entity *se = &p->se, *curr = cfs_rq->curr;
> int this_cpu = 0;
>
> do { } while (0);
>
> update_curr(cfs_rq);
> place_entity(cfs_rq, se, 1);
>
>
> if (sysctl_sched_child_runs_first && this_cpu == task_cpu(p) &&
>   curr && curr->vruntime < se->vruntime) {
>
>
>
>
>  do { typeof(curr->vruntime) tmp = (curr->vruntime); (curr->vruntime) = (se->vruntime); (se->vruntime) = tmp; } while (0);
> }
>
> enqueue_task_fair(rq, p, 0);
> resched_task(rq->curr);
>}
>
>
>
>
>
>static void prio_changed_fair(struct rq *rq, struct task_struct *p,
>         int oldprio, int running)
>{
>
>
>
>
>
> if (running) {
>  if (p->prio > oldprio)
>   resched_task(rq->curr);
> } else
>  check_preempt_curr(rq, p);
>}
>
>
>
>
>static void switched_to_fair(struct rq *rq, struct task_struct *p,
>        int running)
>{
>
>
>
>
>
> if (running)
>  resched_task(rq->curr);
> else
>  check_preempt_curr(rq, p);
>}
>
>
>
>
>
>
>static void set_curr_task_fair(struct rq *rq)
>{
> struct sched_entity *se = &rq->curr->se;
>
> for (; se; se = ((void *)0))
>  set_next_entity(cfs_rq_of(se), se);
>}
># 1517 "kernel/sched_fair.c"
>static const struct sched_class fair_sched_class = {
> .next = &idle_sched_class,
> .enqueue_task = enqueue_task_fair,
> .dequeue_task = dequeue_task_fair,
> .yield_task = yield_task_fair,
>
>
>
>
> .check_preempt_curr = check_preempt_wakeup,
>
> .pick_next_task = pick_next_task_fair,
> .put_prev_task = put_prev_task_fair,
>
>
>
>
>
>
> .set_curr_task = set_curr_task_fair,
> .task_tick = task_tick_fair,
> .task_new = task_new_fair,
>
> .prio_changed = prio_changed_fair,
> .switched_to = switched_to_fair,
>
>
>
>
>};
>
>
>static void print_cfs_stats(struct seq_file *m, int cpu)
>{
> struct cfs_rq *cfs_rq;
>
> do { do { } while (0); (void)0; do { } while (0); } while (0);
> for (cfs_rq = &(&(*((void)((cpu)), &per_cpu__runqueues)))->cfs; cfs_rq; cfs_rq = ((void *)0))
>  print_cfs_rq(m, cpu, cfs_rq);
> do { do { } while (0); (void)0; do { } while (0); } while (0);
>}
># 1487 "kernel/sched.c" 2
>
># 1 "kernel/sched_rt.c" 1
># 48 "kernel/sched_rt.c"
>static inline __attribute__((always_inline)) struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
>{
> return ({ const typeof( ((struct task_struct *)0)->rt ) *__mptr = (rt_se); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,rt) );});
>}
>
>static inline __attribute__((always_inline)) int on_rt_rq(struct sched_rt_entity *rt_se)
>{
> return !list_empty(&rt_se->run_list);
>}
># 160 "kernel/sched_rt.c"
>static inline __attribute__((always_inline)) u64 sched_rt_runtime(struct rt_rq *rt_rq)
>{
> return rt_rq->rt_runtime;
>}
>
>static inline __attribute__((always_inline)) u64 sched_rt_period(struct rt_rq *rt_rq)
>{
> return ((def_rt_bandwidth.rt_period).tv64);
>}
>
>
>
>
>static inline __attribute__((always_inline)) struct rq *rq_of_rt_rq(struct rt_rq *rt_rq)
>{
> return ({ const typeof( ((struct rq *)0)->rt ) *__mptr = (rt_rq); (struct rq *)( (char *)__mptr - __builtin_offsetof(struct rq,rt) );});
>}
>
>static inline __attribute__((always_inline)) struct rt_rq *rt_rq_of_se(struct sched_rt_entity *rt_se)
>{
> struct task_struct *p = rt_task_of(rt_se);
> struct rq *rq = (&(*((void)((task_cpu(p))), &per_cpu__runqueues)));
>
> return &rq->rt;
>}
>
>
>
>
>static inline __attribute__((always_inline)) struct rt_rq *group_rt_rq(struct sched_rt_entity *rt_se)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((always_inline)) void sched_rt_rq_enqueue(struct rt_rq *rt_rq)
>{
>}
>
>static inline __attribute__((always_inline)) void sched_rt_rq_dequeue(struct rt_rq *rt_rq)
>{
>}
>
>static inline __attribute__((always_inline)) int rt_rq_throttled(struct rt_rq *rt_rq)
>{
> return rt_rq->rt_throttled;
>}
>
>static inline __attribute__((always_inline)) cpumask_t sched_rt_period_mask(void)
>{
> return cpu_online_map;
>}
>
>static inline __attribute__((always_inline))
>struct rt_rq *sched_rt_period_rt_rq(struct rt_bandwidth *rt_b, int cpu)
>{
> return &(&(*((void)((cpu)), &per_cpu__runqueues)))->rt;
>}
>
>static inline __attribute__((always_inline)) struct rt_bandwidth *sched_rt_bandwidth(struct rt_rq *rt_rq)
>{
> return &def_rt_bandwidth;
>}
>
>
>
>static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
>{
> int i, idle = 1;
> cpumask_t span;
>
> if (rt_b->rt_runtime == ((u64)~0ULL))
>  return 1;
>
> span = sched_rt_period_mask();
> for ((i) = 0; (i) < 1; (i)++, (void)span) {
>  int enqueue = 0;
>  struct rt_rq *rt_rq = sched_rt_period_rt_rq(rt_b, i);
>  struct rq *rq = rq_of_rt_rq(rt_rq);
>
>  do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
>  if (rt_rq->rt_time) {
>   u64 runtime;
>
>   do { do { } while (0); (void)0; (void)(&rt_rq->rt_runtime_lock); } while (0);
>   runtime = rt_rq->rt_runtime;
>   rt_rq->rt_time -= ({ typeof(rt_rq->rt_time) _min1 = (rt_rq->rt_time); typeof(overrun*runtime) _min2 = (overrun*runtime); (void) (&_min1 == &_min2); _min1 < _min2 ? _min1 : _min2; });
>   if (rt_rq->rt_throttled && rt_rq->rt_time < runtime) {
>    rt_rq->rt_throttled = 0;
>    enqueue = 1;
>   }
>   if (rt_rq->rt_time || rt_rq->rt_nr_running)
>    idle = 0;
>   do { do { } while (0); (void)0; (void)(&rt_rq->rt_runtime_lock); } while (0);
>  }
>
>  if (enqueue)
>   sched_rt_rq_enqueue(rt_rq);
>  do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
> }
>
> return idle;
>}
># 304 "kernel/sched_rt.c"
>static inline __attribute__((always_inline)) int rt_se_prio(struct sched_rt_entity *rt_se)
>{
>
>
>
>
>
>
>
> return rt_task_of(rt_se)->prio;
>}
>
>static int sched_rt_runtime_exceeded(struct rt_rq *rt_rq)
>{
> u64 runtime = sched_rt_runtime(rt_rq);
>
> if (runtime == ((u64)~0ULL))
>  return 0;
>
> if (rt_rq->rt_throttled)
>  return rt_rq_throttled(rt_rq);
>
> if (sched_rt_runtime(rt_rq) >= sched_rt_period(rt_rq))
>  return 0;
># 342 "kernel/sched_rt.c"
> if (rt_rq->rt_time > runtime) {
>  rt_rq->rt_throttled = 1;
>  if (rt_rq_throttled(rt_rq)) {
>   sched_rt_rq_dequeue(rt_rq);
>   return 1;
>  }
> }
>
> return 0;
>}
>
>
>
>
>
>static void update_curr_rt(struct rq *rq)
>{
> struct task_struct *curr = rq->curr;
> struct sched_rt_entity *rt_se = &curr->rt;
> struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
> u64 delta_exec;
>
> if (!task_has_rt_policy(curr))
>  return;
>
> delta_exec = rq->clock - curr->se.exec_start;
> if (__builtin_expect(!!((s64)delta_exec < 0), 0))
>  delta_exec = 0;
>
> do { } while (0);
>
> curr->se.sum_exec_runtime += delta_exec;
> curr->se.exec_start = rq->clock;
> cpuacct_charge(curr, delta_exec);
>
> for (; rt_se; rt_se = ((void *)0)) {
>  rt_rq = rt_rq_of_se(rt_se);
>
>  do { do { } while (0); (void)0; (void)(&rt_rq->rt_runtime_lock); } while (0);
>  rt_rq->rt_time += delta_exec;
>  if (sched_rt_runtime_exceeded(rt_rq))
>   resched_task(curr);
>  do { do { } while (0); (void)0; (void)(&rt_rq->rt_runtime_lock); } while (0);
> }
>}
>
>static inline __attribute__((always_inline))
>void inc_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
>{
> ({ int __ret_warn_on = !!(!rt_prio(rt_se_prio(rt_se))); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("kernel/sched_rt.c", 391); __builtin_expect(!!(__ret_warn_on), 0); });
> rt_rq->rt_nr_running++;
># 412 "kernel/sched_rt.c"
> start_rt_bandwidth(&def_rt_bandwidth);
>
>}
>
>static inline __attribute__((always_inline))
>void dec_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
>{
> ({ int __ret_warn_on = !!(!rt_prio(rt_se_prio(rt_se))); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("kernel/sched_rt.c", 419); __builtin_expect(!!(__ret_warn_on), 0); });
> ({ int __ret_warn_on = !!(!rt_rq->rt_nr_running); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_on_slowpath("kernel/sched_rt.c", 420); __builtin_expect(!!(__ret_warn_on), 0); });
> rt_rq->rt_nr_running--;
># 450 "kernel/sched_rt.c"
>}
>
>static void enqueue_rt_entity(struct sched_rt_entity *rt_se)
>{
> struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
> struct rt_prio_array *array = &rt_rq->active;
> struct rt_rq *group_rq = group_rt_rq(rt_se);
>
> if (group_rq && rt_rq_throttled(group_rq))
>  return;
>
> list_add_tail(&rt_se->run_list, array->queue + rt_se_prio(rt_se));
> __set_bit(rt_se_prio(rt_se), array->bitmap);
>
> inc_rt_tasks(rt_se, rt_rq);
>}
>
>static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
>{
> struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
> struct rt_prio_array *array = &rt_rq->active;
>
> list_del_init(&rt_se->run_list);
> if (list_empty(array->queue + rt_se_prio(rt_se)))
>  __clear_bit(rt_se_prio(rt_se), array->bitmap);
>
> dec_rt_tasks(rt_se, rt_rq);
>}
>
>
>
>
>
>static void dequeue_rt_stack(struct task_struct *p)
>{
> struct sched_rt_entity *rt_se, *back = ((void *)0);
>
> rt_se = &p->rt;
> for (; rt_se; rt_se = ((void *)0)) {
>  rt_se->back = back;
>  back = rt_se;
> }
>
> for (rt_se = back; rt_se; rt_se = rt_se->back) {
>  if (on_rt_rq(rt_se))
>   dequeue_rt_entity(rt_se);
> }
>}
>
>
>
>
>static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup)
>{
> struct sched_rt_entity *rt_se = &p->rt;
>
> if (wakeup)
>  rt_se->timeout = 0;
>
> dequeue_rt_stack(p);
>
>
>
>
> for (; rt_se; rt_se = ((void *)0))
>  enqueue_rt_entity(rt_se);
>}
>
>static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int sleep)
>{
> struct sched_rt_entity *rt_se = &p->rt;
> struct rt_rq *rt_rq;
>
> update_curr_rt(rq);
>
> dequeue_rt_stack(p);
>
>
>
>
> for (; rt_se; rt_se = ((void *)0)) {
>  rt_rq = group_rt_rq(rt_se);
>  if (rt_rq && rt_rq->rt_nr_running)
>   enqueue_rt_entity(rt_se);
> }
>}
>
>
>
>
>
>static
>void requeue_rt_entity(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se)
>{
> struct rt_prio_array *array = &rt_rq->active;
>
> list_move_tail(&rt_se->run_list, array->queue + rt_se_prio(rt_se));
>}
>
>static void requeue_task_rt(struct rq *rq, struct task_struct *p)
>{
> struct sched_rt_entity *rt_se = &p->rt;
> struct rt_rq *rt_rq;
>
> for (; rt_se; rt_se = ((void *)0)) {
>  rt_rq = rt_rq_of_se(rt_se);
>  requeue_rt_entity(rt_rq, rt_se);
> }
>}
>
>static void yield_task_rt(struct rq *rq)
>{
> requeue_task_rt(rq, rq->curr);
>}
># 607 "kernel/sched_rt.c"
>static void check_preempt_curr_rt(struct rq *rq, struct task_struct *p)
>{
> if (p->prio < rq->curr->prio)
>  resched_task(rq->curr);
>}
>
>static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,
>         struct rt_rq *rt_rq)
>{
> struct rt_prio_array *array = &rt_rq->active;
> struct sched_rt_entity *next = ((void *)0);
> struct list_head *queue;
> int idx;
>
> idx = sched_find_first_bit(array->bitmap);
> do { if (__builtin_expect(!!(idx >= 100), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched_rt.c", 622, (__func__)); panic("BUG!"); } while (0); } while(0);
>
> queue = array->queue + idx;
> next = ({ const typeof( ((struct sched_rt_entity *)0)->run_list ) *__mptr = (queue->next); (struct sched_rt_entity *)( (char *)__mptr - __builtin_offsetof(struct sched_rt_entity,run_list) );});
>
> return next;
>}
>
>static struct task_struct *pick_next_task_rt(struct rq *rq)
>{
> struct sched_rt_entity *rt_se;
> struct task_struct *p;
> struct rt_rq *rt_rq;
>
> rt_rq = &rq->rt;
>
> if (__builtin_expect(!!(!rt_rq->rt_nr_running), 0))
>  return ((void *)0);
>
> if (rt_rq_throttled(rt_rq))
>  return ((void *)0);
>
> do {
>  rt_se = pick_next_rt_entity(rq, rt_rq);
>  do { if (__builtin_expect(!!(!rt_se), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched_rt.c", 646, (__func__)); panic("BUG!"); } while (0); } while(0);
>  rt_rq = group_rt_rq(rt_se);
> } while (rt_rq);
>
> p = rt_task_of(rt_se);
> p->se.exec_start = rq->clock;
> return p;
>}
>
>static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
>{
> update_curr_rt(rq);
> p->se.exec_start = 0;
>}
># 1193 "kernel/sched_rt.c"
>static void switched_to_rt(struct rq *rq, struct task_struct *p,
>      int running)
>{
> int check_resched = 1;
># 1205 "kernel/sched_rt.c"
> if (!running) {
>
>
>
>
>
>
>  if (check_resched && p->prio < rq->curr->prio)
>   resched_task(rq->curr);
> }
>}
>
>
>
>
>
>static void prio_changed_rt(struct rq *rq, struct task_struct *p,
>       int oldprio, int running)
>{
> if (running) {
># 1242 "kernel/sched_rt.c"
>  if (oldprio < p->prio)
>   resched_task(p);
>
> } else {
>
>
>
>
>
>  if (p->prio < rq->curr->prio)
>   resched_task(rq->curr);
> }
>}
>
>static void watchdog(struct rq *rq, struct task_struct *p)
>{
> unsigned long soft, hard;
>
> if (!p->signal)
>  return;
>
> soft = p->signal->rlim[15].rlim_cur;
> hard = p->signal->rlim[15].rlim_max;
>
> if (soft != (~0UL)) {
>  unsigned long next;
>
>  p->rt.timeout++;
>  next = (((({ typeof(soft) _min1 = (soft); typeof(hard) _min2 = (hard); (void) (&_min1 == &_min2); _min1 < _min2 ? _min1 : _min2; })) + (1000000L/100) - 1) / (1000000L/100));
>  if (p->rt.timeout > next)
>   p->it_sched_expires = p->se.sum_exec_runtime;
> }
>}
>
>static void task_tick_rt(struct rq *rq, struct task_struct *p, int queued)
>{
> update_curr_rt(rq);
>
> watchdog(rq, p);
>
>
>
>
>
> if (p->policy != 2)
>  return;
>
> if (--p->rt.time_slice)
>  return;
>
> p->rt.time_slice = (100 * 100 / 1000);
>
>
>
>
>
> if (p->rt.run_list.prev != p->rt.run_list.next) {
>  requeue_task_rt(rq, p);
>  set_tsk_need_resched(p);
> }
>}
>
>static void set_curr_task_rt(struct rq *rq)
>{
> struct task_struct *p = rq->curr;
>
> p->se.exec_start = rq->clock;
>}
>
>static const struct sched_class rt_sched_class = {
> .next = &fair_sched_class,
> .enqueue_task = enqueue_task_rt,
> .dequeue_task = dequeue_task_rt,
> .yield_task = yield_task_rt,
>
>
>
>
> .check_preempt_curr = check_preempt_curr_rt,
>
> .pick_next_task = pick_next_task_rt,
> .put_prev_task = put_prev_task_rt,
># 1337 "kernel/sched_rt.c"
> .set_curr_task = set_curr_task_rt,
> .task_tick = task_tick_rt,
>
> .prio_changed = prio_changed_rt,
> .switched_to = switched_to_rt,
>};
># 1488 "kernel/sched.c" 2
>
>
># 1 "kernel/sched_debug.c" 1
># 13 "kernel/sched_debug.c"
>
># 1 "include/linux/proc_fs.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/magic.h" 1
># 8 "include/linux/proc_fs.h" 2
>
>
>struct net;
>struct completion;
># 28 "include/linux/proc_fs.h"
>enum {
> PROC_ROOT_INO = 1,
>};
># 47 "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);
>
>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;
> const struct inode_operations *proc_iops;
># 70 "include/linux/proc_fs.h"
> const struct file_operations *proc_fops;
> 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 pde_users;
> spinlock_t pde_unload_lock;
> struct completion *pde_unload_completion;
>};
>
>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_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 *);
>void task_mem(struct seq_file *, struct mm_struct *);
>void clear_refs_smap(struct mm_struct *mm);
>
>struct proc_dir_entry *de_get(struct proc_dir_entry *de);
>void de_put(struct proc_dir_entry *de);
>
>extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
>      struct proc_dir_entry *parent);
>struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
>    struct proc_dir_entry *parent,
>    const struct file_operations *proc_fops,
>    void *data);
>extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
>
>extern struct vfsmount *proc_mnt;
>struct pid_namespace;
>extern int proc_fill_super(struct super_block *);
>extern struct inode *proc_get_inode(struct super_block *, unsigned int, struct proc_dir_entry *);
># 137 "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;
>
>extern int pid_ns_prepare_proc(struct pid_namespace *ns);
>extern void pid_ns_release_proc(struct pid_namespace *ns);
>
>
>
>
>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);
># 171 "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 *proc_create(const char *name, mode_t mode,
> struct proc_dir_entry *parent, const struct file_operations *proc_fops)
>{
> return proc_create_data(name, mode, parent, proc_fops, ((void *)0));
>}
>
>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;
>}
>
>extern struct proc_dir_entry *proc_net_fops_create(struct net *net,
> const char *name, mode_t mode, const struct file_operations *fops);
>extern void proc_net_remove(struct net *net, const char *name);
>extern struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
> struct proc_dir_entry *parent);
>
>
>
>extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
>extern struct file *get_mm_exe_file(struct mm_struct *mm);
>extern void dup_mm_exe_file(struct mm_struct *oldmm, struct mm_struct *newmm);
># 274 "include/linux/proc_fs.h"
>extern void kclist_add(struct kcore_list *, void *, size_t);
>
>
>union proc_op {
> int (*proc_get_link)(struct inode *, struct path *);
> int (*proc_read)(struct task_struct *task, char *page);
> int (*proc_show)(struct seq_file *m,
>  struct pid_namespace *ns, struct pid *pid,
>  struct task_struct *task);
>};
>
>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;
>}
>
>static inline __attribute__((always_inline)) struct net *PDE_NET(struct proc_dir_entry *pde)
>{
> return pde->parent->data;
>}
>
>struct net *get_proc_net(const struct inode *inode);
>
>struct proc_maps_private {
> struct pid *pid;
> struct task_struct *task;
>
> struct vm_area_struct *tail_vma;
>
>};
># 14 "kernel/sched_debug.c" 2
>
>
>
># 1 "include/linux/kallsyms.h" 1
># 17 "include/linux/kallsyms.h"
>unsigned long kallsyms_lookup_name(const char *name);
>
>extern int kallsyms_lookup_size_offset(unsigned long addr,
>      unsigned long *symbolsize,
>      unsigned long *offset);
>
>
>const char *kallsyms_lookup(unsigned long addr,
>       unsigned long *symbolsize,
>       unsigned long *offset,
>       char **modname, char *namebuf);
>
>
>extern int sprint_symbol(char *buffer, unsigned long address);
>
>
>extern void __print_symbol(const char *fmt, unsigned long address);
>
>int lookup_symbol_name(unsigned long addr, char *symname);
>int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
># 81 "include/linux/kallsyms.h"
>static void __check_printsym_format(const char *fmt, ...)
>__attribute__((format(printf,1,2)));
>static inline __attribute__((always_inline)) void __check_printsym_format(const char *fmt, ...)
>{
>}
>
>static inline __attribute__((always_inline)) void print_symbol(const char *fmt, unsigned long addr)
>{
> __check_printsym_format(fmt, "");
> __print_symbol(fmt, (unsigned long)
>         __builtin_extract_return_addr((void *)addr));
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void print_fn_descriptor_symbol(const char *fmt, void *addr)
>{
>
>
>
> print_symbol(fmt, (unsigned long)addr);
>}
># 17 "kernel/sched_debug.c" 2
>
># 1 "include/linux/utsname.h" 1
>
>
>
>
>
>struct oldold_utsname {
> char sysname[9];
> char nodename[9];
> char release[9];
> char version[9];
> char machine[9];
>};
>
>
>
>struct old_utsname {
> char sysname[65];
> char nodename[65];
> char release[65];
> char version[65];
> char machine[65];
>};
>
>struct new_utsname {
> char sysname[65];
> char nodename[65];
> char release[65];
> char version[65];
> char machine[65];
> char domainname[65];
>};
># 41 "include/linux/utsname.h"
>struct uts_namespace {
> struct kref kref;
> struct new_utsname name;
>};
>extern struct uts_namespace init_uts_ns;
># 62 "include/linux/utsname.h"
>static inline __attribute__((always_inline)) void get_uts_ns(struct uts_namespace *ns)
>{
>}
>
>static inline __attribute__((always_inline)) void put_uts_ns(struct uts_namespace *ns)
>{
>}
>
>static inline __attribute__((always_inline)) struct uts_namespace *copy_utsname(unsigned long flags,
>     struct uts_namespace *ns)
>{
> if (flags & 0x04000000)
>  return ERR_PTR(-22);
>
> return ns;
>}
>
>
>static inline __attribute__((always_inline)) struct new_utsname *utsname(void)
>{
> return &(current_thread_info()->task)->nsproxy->uts_ns->name;
>}
>
>static inline __attribute__((always_inline)) struct new_utsname *init_utsname(void)
>{
> return &init_uts_ns.name;
>}
>
>extern struct rw_semaphore uts_sem;
># 18 "kernel/sched_debug.c" 2
># 34 "kernel/sched_debug.c"
>static long long nsec_high(unsigned long long nsec)
>{
> if ((long long)nsec < 0) {
>  nsec = -nsec;
>  ({ uint32_t __base = (1000000); uint32_t __rem; __rem = ((uint64_t)(nsec)) % __base; (nsec) = ((uint64_t)(nsec)) / __base; __rem; });
>  return -nsec;
> }
> ({ uint32_t __base = (1000000); uint32_t __rem; __rem = ((uint64_t)(nsec)) % __base; (nsec) = ((uint64_t)(nsec)) / __base; __rem; });
>
> return nsec;
>}
>
>static unsigned long nsec_low(unsigned long long nsec)
>{
> if ((long long)nsec < 0)
>  nsec = -nsec;
>
> return ({ uint32_t __base = (1000000); uint32_t __rem; __rem = ((uint64_t)(nsec)) % __base; (nsec) = ((uint64_t)(nsec)) / __base; __rem; });
>}
>
>
>
>static void
>print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
>{
> if (rq->curr == p)
>  do { if (m) seq_printf(m, "R"); else printk("R"); } while (0);
> else
>  do { if (m) seq_printf(m, " "); else printk(" "); } while (0);
>
> do { if (m) seq_printf(m, "%15s %5d %9Ld.%06ld %9Ld %5d ", p->comm, p->pid, nsec_high(p->se.vruntime), nsec_low(p->se.vruntime), (long long)(p->nvcsw + p->nivcsw), p->prio); else printk("%15s %5d %9Ld.%06ld %9Ld %5d ", p->comm, p->pid, nsec_high(p->se.vruntime), nsec_low(p->se.vruntime), (long long)(p->nvcsw + p->nivcsw), p->prio); } while (0);
># 75 "kernel/sched_debug.c"
> do { if (m) seq_printf(m, "%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld", 0LL, 0LL, 0LL, 0L, 0LL, 0L, 0LL, 0L); else printk("%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld", 0LL, 0LL, 0LL, 0L, 0LL, 0L, 0LL, 0L); } while (0);
># 87 "kernel/sched_debug.c"
> do { if (m) seq_printf(m, "\n"); else printk("\n"); } while (0);
>}
>
>static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu)
>{
> struct task_struct *g, *p;
> unsigned long flags;
>
> do { if (m) seq_printf(m, "\nrunnable tasks:\n" "            task   PID         tree-key  switches  prio" "     exec-runtime         sum-exec        sum-sleep\n" "------------------------------------------------------" "----------------------------------------------------\n"); else printk("\nrunnable tasks:\n" "            task   PID         tree-key  switches  prio" "     exec-runtime         sum-exec        sum-sleep\n" "------------------------------------------------------" "----------------------------------------------------\n"); } while (0);
>
>
>
>
>
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0); } while (0);
>
> for (g = p = &init_task ; (g = p = ({ const typeof( ((struct task_struct *)0)->tasks ) *__mptr = (({ typeof((g)->tasks.next) _________p1 = (*(volatile typeof((g)->tasks.next) *)&((g)->tasks.next)); do { } while (0); (_________p1); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,tasks) );})) != &init_task ; ) do {
>  if (!p->se.on_rq || task_cpu(p) != rq_cpu)
>   continue;
>
>  print_task(m, rq, p);
> } while ((p = next_thread(p)) != g);
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0); } while (0);
>}
>
>void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
>{
> s64 MIN_vruntime = -1, min_vruntime, max_vruntime = -1,
>  spread, rq0_min_vruntime, spread0;
> struct rq *rq = &(*((void)(cpu), &per_cpu__runqueues));
> struct sched_entity *last;
> unsigned long flags;
>
>
> do { if (m) seq_printf(m, "\ncfs_rq[%d]:\n", cpu); else printk("\ncfs_rq[%d]:\n", cpu); } while (0);
># 138 "kernel/sched_debug.c"
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "exec_clock", nsec_high(cfs_rq->exec_clock), nsec_low(cfs_rq->exec_clock)); else printk("  .%-30s: %Ld.%06ld\n", "exec_clock", nsec_high(cfs_rq->exec_clock), nsec_low(cfs_rq->exec_clock)); } while (0);
>
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
> if (cfs_rq->rb_leftmost)
>  MIN_vruntime = (__pick_next_entity(cfs_rq))->vruntime;
> last = __pick_last_entity(cfs_rq);
> if (last)
>  max_vruntime = last->vruntime;
> min_vruntime = rq->cfs.min_vruntime;
> rq0_min_vruntime = (*((void)(0), &per_cpu__runqueues)).cfs.min_vruntime;
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "MIN_vruntime", nsec_high(MIN_vruntime), nsec_low(MIN_vruntime)); else printk("  .%-30s: %Ld.%06ld\n", "MIN_vruntime", nsec_high(MIN_vruntime), nsec_low(MIN_vruntime)); } while (0);
>
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "min_vruntime", nsec_high(min_vruntime), nsec_low(min_vruntime)); else printk("  .%-30s: %Ld.%06ld\n", "min_vruntime", nsec_high(min_vruntime), nsec_low(min_vruntime)); } while (0);
>
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "max_vruntime", nsec_high(max_vruntime), nsec_low(max_vruntime)); else printk("  .%-30s: %Ld.%06ld\n", "max_vruntime", nsec_high(max_vruntime), nsec_low(max_vruntime)); } while (0);
>
> spread = max_vruntime - MIN_vruntime;
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "spread", nsec_high(spread), nsec_low(spread)); else printk("  .%-30s: %Ld.%06ld\n", "spread", nsec_high(spread), nsec_low(spread)); } while (0);
>
> spread0 = min_vruntime - rq0_min_vruntime;
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "spread0", nsec_high(spread0), nsec_low(spread0)); else printk("  .%-30s: %Ld.%06ld\n", "spread0", nsec_high(spread0), nsec_low(spread0)); } while (0);
>
> do { if (m) seq_printf(m, "  .%-30s: %ld\n", "nr_running", cfs_rq->nr_running); else printk("  .%-30s: %ld\n", "nr_running", cfs_rq->nr_running); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %ld\n", "load", cfs_rq->load.weight); else printk("  .%-30s: %ld\n", "load", cfs_rq->load.weight); } while (0);
>
>
>
>
> do { if (m) seq_printf(m, "  .%-30s: %ld\n", "nr_spread_over", cfs_rq->nr_spread_over); else printk("  .%-30s: %ld\n", "nr_spread_over", cfs_rq->nr_spread_over); } while (0);
>
>}
>
>static void print_cpu(struct seq_file *m, int cpu)
>{
> struct rq *rq = &(*((void)(cpu), &per_cpu__runqueues));
># 184 "kernel/sched_debug.c"
> do { if (m) seq_printf(m, "\ncpu#%d\n", cpu); else printk("\ncpu#%d\n", cpu); } while (0);
>
>
>
>
>
>
>
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "nr_running", (long long)(rq->nr_running)); else printk("  .%-30s: %Ld\n", "nr_running", (long long)(rq->nr_running)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %lu\n", "load", rq->load.weight); else printk("  .%-30s: %lu\n", "load", rq->load.weight); } while (0);
>
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "nr_switches", (long long)(rq->nr_switches)); else printk("  .%-30s: %Ld\n", "nr_switches", (long long)(rq->nr_switches)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "nr_load_updates", (long long)(rq->nr_load_updates)); else printk("  .%-30s: %Ld\n", "nr_load_updates", (long long)(rq->nr_load_updates)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "nr_uninterruptible", (long long)(rq->nr_uninterruptible)); else printk("  .%-30s: %Ld\n", "nr_uninterruptible", (long long)(rq->nr_uninterruptible)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %lu\n", "jiffies", jiffies); else printk("  .%-30s: %lu\n", "jiffies", jiffies); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "next_balance", nsec_high(rq->next_balance), nsec_low(rq->next_balance)); else printk("  .%-30s: %Ld.%06ld\n", "next_balance", nsec_high(rq->next_balance), nsec_low(rq->next_balance)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "curr->pid", (long long)(rq->curr->pid)); else printk("  .%-30s: %Ld\n", "curr->pid", (long long)(rq->curr->pid)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld.%06ld\n", "clock", nsec_high(rq->clock), nsec_low(rq->clock)); else printk("  .%-30s: %Ld.%06ld\n", "clock", nsec_high(rq->clock), nsec_low(rq->clock)); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "cpu_load[0]", (long long)(rq->cpu_load[0])); else printk("  .%-30s: %Ld\n", "cpu_load[0]", (long long)(rq->cpu_load[0])); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "cpu_load[1]", (long long)(rq->cpu_load[1])); else printk("  .%-30s: %Ld\n", "cpu_load[1]", (long long)(rq->cpu_load[1])); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "cpu_load[2]", (long long)(rq->cpu_load[2])); else printk("  .%-30s: %Ld\n", "cpu_load[2]", (long long)(rq->cpu_load[2])); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "cpu_load[3]", (long long)(rq->cpu_load[3])); else printk("  .%-30s: %Ld\n", "cpu_load[3]", (long long)(rq->cpu_load[3])); } while (0);
> do { if (m) seq_printf(m, "  .%-30s: %Ld\n", "cpu_load[4]", (long long)(rq->cpu_load[4])); else printk("  .%-30s: %Ld\n", "cpu_load[4]", (long long)(rq->cpu_load[4])); } while (0);
>
>
>
> print_cfs_stats(m, cpu);
>
> print_rq(m, rq, cpu);
>}
>
>static int sched_debug_show(struct seq_file *m, void *v)
>{
> u64 now = ((ktime_get()).tv64);
> int cpu;
>
> do { if (m) seq_printf(m, "Sched Debug Version: v0.07, %s %.*s\n", init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); else printk("Sched Debug Version: v0.07, %s %.*s\n", init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); } while (0);
>
>
>
>
> do { if (m) seq_printf(m, "now at %Lu.%06ld msecs\n", nsec_high(now), nsec_low(now)); else printk("now at %Lu.%06ld msecs\n", nsec_high(now), nsec_low(now)); } while (0);
>
>
>
>
>
> do { if (m) seq_printf(m, "  .%-40s: %Ld.%06ld\n", "sysctl_sched_latency", nsec_high(sysctl_sched_latency), nsec_low(sysctl_sched_latency)); else printk("  .%-40s: %Ld.%06ld\n", "sysctl_sched_latency", nsec_high(sysctl_sched_latency), nsec_low(sysctl_sched_latency)); } while (0);
> do { if (m) seq_printf(m, "  .%-40s: %Ld.%06ld\n", "sysctl_sched_min_granularity", nsec_high(sysctl_sched_min_granularity), nsec_low(sysctl_sched_min_granularity)); else printk("  .%-40s: %Ld.%06ld\n", "sysctl_sched_min_granularity", nsec_high(sysctl_sched_min_granularity), nsec_low(sysctl_sched_min_granularity)); } while (0);
> do { if (m) seq_printf(m, "  .%-40s: %Ld.%06ld\n", "sysctl_sched_wakeup_granularity", nsec_high(sysctl_sched_wakeup_granularity), nsec_low(sysctl_sched_wakeup_granularity)); else printk("  .%-40s: %Ld.%06ld\n", "sysctl_sched_wakeup_granularity", nsec_high(sysctl_sched_wakeup_granularity), nsec_low(sysctl_sched_wakeup_granularity)); } while (0);
> do { if (m) seq_printf(m, "  .%-40s: %Ld.%06ld\n", "sysctl_sched_child_runs_first", nsec_high(sysctl_sched_child_runs_first), nsec_low(sysctl_sched_child_runs_first)); else printk("  .%-40s: %Ld.%06ld\n", "sysctl_sched_child_runs_first", nsec_high(sysctl_sched_child_runs_first), nsec_low(sysctl_sched_child_runs_first)); } while (0);
> do { if (m) seq_printf(m, "  .%-40s: %Ld\n", "sysctl_sched_features", (long long)(sysctl_sched_features)); else printk("  .%-40s: %Ld\n", "sysctl_sched_features", (long long)(sysctl_sched_features)); } while (0);
>
>
>
> for (((cpu)) = 0; ((cpu)) < 1; ((cpu))++, (void)cpu_online_map)
>  print_cpu(m, cpu);
>
> do { if (m) seq_printf(m, "\n"); else printk("\n"); } while (0);
>
> return 0;
>}
>
>static void sysrq_sched_debug_show(void)
>{
> sched_debug_show(((void *)0), ((void *)0));
>}
>
>static int sched_debug_open(struct inode *inode, struct file *filp)
>{
> return single_open(filp, sched_debug_show, ((void *)0));
>}
>
>static const struct file_operations sched_debug_fops = {
> .open = sched_debug_open,
> .read = seq_read,
> .llseek = seq_lseek,
> .release = single_release,
>};
>
>static int __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) init_sched_debug_procfs(void)
>{
> struct proc_dir_entry *pe;
>
> pe = proc_create("sched_debug", 0644, ((void *)0), &sched_debug_fops);
> if (!pe)
>  return -12;
> return 0;
>}
>
>static initcall_t __initcall_init_sched_debug_procfs6 __attribute__((__used__)) __attribute__((__section__(".initcall" "6" ".init"))) = init_sched_debug_procfs;
>
>void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
>{
> unsigned long nr_switches;
> unsigned long flags;
> int num_threads = 1;
>
> do { do { } while (0); (void)0; do { } while (0); } while (0);
> if (lock_task_sighand(p, &flags)) {
>  num_threads = ((&p->signal->count)->counter);
>  unlock_task_sighand(p, &flags);
> }
> do { do { } while (0); (void)0; do { } while (0); } while (0);
>
> do { if (m) seq_printf(m, "%s (%d, #threads: %d)\n", p->comm, p->pid, num_threads); else printk("%s (%d, #threads: %d)\n", p->comm, p->pid, num_threads); } while (0);
> do { if (m) seq_printf(m, "---------------------------------------------------------\n"); else printk("---------------------------------------------------------\n"); } while (0);
># 301 "kernel/sched_debug.c"
> do { if (m) seq_printf(m, "%-35s:%14Ld.%06ld\n", "se.exec_start", nsec_high((long long)p->se.exec_start), nsec_low((long long)p->se.exec_start)); else printk("%-35s:%14Ld.%06ld\n", "se.exec_start", nsec_high((long long)p->se.exec_start), nsec_low((long long)p->se.exec_start)); } while (0);
> do { if (m) seq_printf(m, "%-35s:%14Ld.%06ld\n", "se.vruntime", nsec_high((long long)p->se.vruntime), nsec_low((long long)p->se.vruntime)); else printk("%-35s:%14Ld.%06ld\n", "se.vruntime", nsec_high((long long)p->se.vruntime), nsec_low((long long)p->se.vruntime)); } while (0);
> do { if (m) seq_printf(m, "%-35s:%14Ld.%06ld\n", "se.sum_exec_runtime", nsec_high((long long)p->se.sum_exec_runtime), nsec_low((long long)p->se.sum_exec_runtime)); else printk("%-35s:%14Ld.%06ld\n", "se.sum_exec_runtime", nsec_high((long long)p->se.sum_exec_runtime), nsec_low((long long)p->se.sum_exec_runtime)); } while (0);
> do { if (m) seq_printf(m, "%-35s:%14Ld.%06ld\n", "se.avg_overlap", nsec_high((long long)p->se.avg_overlap), nsec_low((long long)p->se.avg_overlap)); else printk("%-35s:%14Ld.%06ld\n", "se.avg_overlap", nsec_high((long long)p->se.avg_overlap), nsec_low((long long)p->se.avg_overlap)); } while (0);
>
> nr_switches = p->nvcsw + p->nivcsw;
># 358 "kernel/sched_debug.c"
> do { if (m) seq_printf(m, "%-35s:%21Ld\n", "nr_switches", (long long)nr_switches); else printk("%-35s:%21Ld\n", "nr_switches", (long long)nr_switches); } while (0);
> do { if (m) seq_printf(m, "%-35s:%21Ld\n", "nr_voluntary_switches", (long long)p->nvcsw); else printk("%-35s:%21Ld\n", "nr_voluntary_switches", (long long)p->nvcsw); } while (0);
>
> do { if (m) seq_printf(m, "%-35s:%21Ld\n", "nr_involuntary_switches", (long long)p->nivcsw); else printk("%-35s:%21Ld\n", "nr_involuntary_switches", (long long)p->nivcsw); } while (0);
>
>
> do { if (m) seq_printf(m, "%-35s:%21Ld\n", "se.load.weight", (long long)p->se.load.weight); else printk("%-35s:%21Ld\n", "se.load.weight", (long long)p->se.load.weight); } while (0);
> do { if (m) seq_printf(m, "%-35s:%21Ld\n", "policy", (long long)p->policy); else printk("%-35s:%21Ld\n", "policy", (long long)p->policy); } while (0);
> do { if (m) seq_printf(m, "%-35s:%21Ld\n", "prio", (long long)p->prio); else printk("%-35s:%21Ld\n", "prio", (long long)p->prio); } while (0);
>
>
>
>
>
> {
>  u64 t0, t1;
>
>  t0 = sched_clock();
>  t1 = sched_clock();
>  do { if (m) seq_printf(m, "%-35s:%21Ld\n", "clock-delta", (long long)(t1-t0)); else printk("%-35s:%21Ld\n", "clock-delta", (long long)(t1-t0)); } while (0);
>
> }
>}
>
>void proc_sched_set_task(struct task_struct *p)
>{
># 411 "kernel/sched_debug.c"
> p->se.sum_exec_runtime = 0;
> p->se.prev_sum_exec_runtime = 0;
> p->nvcsw = 0;
> p->nivcsw = 0;
>}
># 1490 "kernel/sched.c" 2
>
>
>
>
>static inline __attribute__((always_inline)) void inc_load(struct rq *rq, const struct task_struct *p)
>{
> update_load_add(&rq->load, p->se.load.weight);
>}
>
>static inline __attribute__((always_inline)) void dec_load(struct rq *rq, const struct task_struct *p)
>{
> update_load_sub(&rq->load, p->se.load.weight);
>}
>
>static void inc_nr_running(struct task_struct *p, struct rq *rq)
>{
> rq->nr_running++;
> inc_load(rq, p);
>}
>
>static void dec_nr_running(struct task_struct *p, struct rq *rq)
>{
> rq->nr_running--;
> dec_load(rq, p);
>}
>
>static void set_load_weight(struct task_struct *p)
>{
> if (task_has_rt_policy(p)) {
>  p->se.load.weight = prio_to_weight[0] * 2;
>  p->se.load.inv_weight = prio_to_wmult[0] >> 1;
>  return;
> }
>
>
>
>
> if (p->policy == 5) {
>  p->se.load.weight = 2;
>  p->se.load.inv_weight = (1 << 31);
>  return;
> }
>
> p->se.load.weight = prio_to_weight[p->static_prio - 100];
> p->se.load.inv_weight = prio_to_wmult[p->static_prio - 100];
>}
>
>static void enqueue_task(struct rq *rq, struct task_struct *p, int wakeup)
>{
> do { } while (0);
> p->sched_class->enqueue_task(rq, p, wakeup);
> p->se.on_rq = 1;
>}
>
>static void dequeue_task(struct rq *rq, struct task_struct *p, int sleep)
>{
> p->sched_class->dequeue_task(rq, p, sleep);
> p->se.on_rq = 0;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int __normal_prio(struct task_struct *p)
>{
> return p->static_prio;
>}
># 1565 "kernel/sched.c"
>static inline __attribute__((always_inline)) int normal_prio(struct task_struct *p)
>{
> int prio;
>
> if (task_has_rt_policy(p))
>  prio = 100 -1 - p->rt_priority;
> else
>  prio = __normal_prio(p);
> return prio;
>}
># 1583 "kernel/sched.c"
>static int effective_prio(struct task_struct *p)
>{
> p->normal_prio = normal_prio(p);
>
>
>
>
>
> if (!rt_prio(p->prio))
>  return p->normal_prio;
> return p->prio;
>}
>
>
>
>
>static void activate_task(struct rq *rq, struct task_struct *p, int wakeup)
>{
> if (((p->state & 2) != 0))
>  rq->nr_uninterruptible--;
>
> enqueue_task(rq, p, wakeup);
> inc_nr_running(p, rq);
>}
>
>
>
>
>static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep)
>{
> if (((p->state & 2) != 0))
>  rq->nr_uninterruptible++;
>
> dequeue_task(rq, p, sleep);
> dec_nr_running(p, rq);
>}
>
>
>
>
>
>inline __attribute__((always_inline)) int task_curr(const struct task_struct *p)
>{
> return ((&(*((void)((task_cpu(p))), &per_cpu__runqueues)))->curr) == p;
>}
>
>
>unsigned long weighted_cpuload(const int cpu)
>{
> return (&(*((void)((cpu)), &per_cpu__runqueues)))->load.weight;
>}
>
>static inline __attribute__((always_inline)) void __set_task_cpu(struct task_struct *p, unsigned int cpu)
>{
> set_task_rq(p, cpu);
># 1647 "kernel/sched.c"
>}
>
>static inline __attribute__((always_inline)) void check_class_changed(struct rq *rq, struct task_struct *p,
>           const struct sched_class *prev_class,
>           int oldprio, int running)
>{
> if (prev_class != p->sched_class) {
>  if (prev_class->switched_from)
>   prev_class->switched_from(rq, p, running);
>  p->sched_class->switched_to(rq, p, running);
> } else
>  p->sched_class->prio_changed(rq, p, oldprio, running);
>}
># 2068 "kernel/sched.c"
>static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
>{
> int cpu, orig_cpu, this_cpu, success = 0;
> unsigned long flags;
> long old_state;
> struct rq *rq;
>
> if (!(sysctl_sched_features & (1UL << __SCHED_FEAT_SYNC_WAKEUPS)))
>  sync = 0;
>
> __asm__ __volatile__("": : :"memory");
> rq = task_rq_lock(p, &flags);
> old_state = p->state;
> if (!(old_state & state))
>  goto out;
>
> if (p->se.on_rq)
>  goto out_running;
>
> cpu = task_cpu(p);
> orig_cpu = cpu;
> this_cpu = 0;
># 2128 "kernel/sched.c"
> do { } while (0);
> if (sync)
>  do { } while (0);
> if (orig_cpu != cpu)
>  do { } while (0);
> if (cpu == this_cpu)
>  do { } while (0);
> else
>  do { } while (0);
> update_rq_clock(rq);
> activate_task(rq, p, 1);
> success = 1;
>
>out_running:
> check_preempt_curr(rq, p);
>
> p->state = 0;
>
>
>
>
>out:
> task_rq_unlock(rq, &flags);
>
> return success;
>}
>
>int wake_up_process(struct task_struct *p)
>{
> return try_to_wake_up(p, ((1 | 2) | 4 | 8), 0);
>}
>extern typeof(wake_up_process) wake_up_process; static const char __kstrtab_wake_up_process[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "wake_up_process"; static const struct kernel_symbol __ksymtab_wake_up_process __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&wake_up_process, __kstrtab_wake_up_process };
>
>int wake_up_state(struct task_struct *p, unsigned int state)
>{
> return try_to_wake_up(p, state, 0);
>}
>
>
>
>
>
>
>
>static void __sched_fork(struct task_struct *p)
>{
> p->se.exec_start = 0;
> p->se.sum_exec_runtime = 0;
> p->se.prev_sum_exec_runtime = 0;
> p->se.last_wakeup = 0;
> p->se.avg_overlap = 0;
># 2192 "kernel/sched.c"
> INIT_LIST_HEAD(&p->rt.run_list);
> p->se.on_rq = 0;
> INIT_LIST_HEAD(&p->se.group_node);
># 2206 "kernel/sched.c"
> p->state = 0;
>}
>
>
>
>
>void sched_fork(struct task_struct *p, int clone_flags)
>{
> int cpu = ({ do { } while (0); 0; });
>
> __sched_fork(p);
>
>
>
>
> set_task_cpu(p, cpu);
>
>
>
>
> p->prio = (current_thread_info()->task)->normal_prio;
> if (!rt_prio(p->prio))
>  p->sched_class = &fair_sched_class;
># 2241 "kernel/sched.c"
> do { } while (0);
>}
># 2251 "kernel/sched.c"
>void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
>{
> unsigned long flags;
> struct rq *rq;
>
> rq = task_rq_lock(p, &flags);
> do { if (__builtin_expect(!!(p->state != 0), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched.c", 2257, (__func__)); panic("BUG!"); } while (0); } while(0);
> update_rq_clock(rq);
>
> p->prio = effective_prio(p);
>
> if (!p->sched_class->task_new || !(current_thread_info()->task)->se.on_rq) {
>  activate_task(rq, p, 0);
> } else {
>
>
>
>
>  p->sched_class->task_new(rq, p);
>  inc_nr_running(p, rq);
> }
> check_preempt_curr(rq, p);
>
>
>
>
> task_rq_unlock(rq, &flags);
>}
># 2326 "kernel/sched.c"
>static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
>{
>}
>
>static void
>fire_sched_out_preempt_notifiers(struct task_struct *curr,
>     struct task_struct *next)
>{
>}
># 2351 "kernel/sched.c"
>static inline __attribute__((always_inline)) void
>prepare_task_switch(struct rq *rq, struct task_struct *prev,
>      struct task_struct *next)
>{
> fire_sched_out_preempt_notifiers(prev, next);
> prepare_lock_switch(rq, next);
> do { } while (0);
>}
># 2375 "kernel/sched.c"
>static void finish_task_switch(struct rq *rq, struct task_struct *prev)
>
>{
> struct mm_struct *mm = rq->prev_mm;
> long prev_state;
>
> rq->prev_mm = ((void *)0);
># 2394 "kernel/sched.c"
> prev_state = prev->state;
> do { } while (0);
> finish_lock_switch(rq, prev);
>
>
>
>
>
> fire_sched_in_preempt_notifiers((current_thread_info()->task));
> if (mm)
>  mmdrop(mm);
> if (__builtin_expect(!!(prev_state == 64), 0)) {
>
>
>
>
>  kprobe_flush_task(prev);
>  put_task_struct(prev);
> }
>}
>
>
>
>
>
> void schedule_tail(struct task_struct *prev)
>
>{
> struct rq *rq = (&per_cpu__runqueues);
>
> finish_task_switch(rq, prev);
>
>
>
>
> if ((current_thread_info()->task)->set_child_tid)
>  ({ __typeof__(*((current_thread_info()->task)->set_child_tid)) *private_ptr = ((current_thread_info()->task)->set_child_tid); ((((unsigned long) (private_ptr) <= ((unsigned long) (private_ptr) + (sizeof(*private_ptr)))) && ((((unsigned long) (private_ptr) < (task_size)) && (((unsigned long) (private_ptr) + (sizeof(*private_ptr))) < (task_size))) || ((1 == 0) && ((unsigned long) (private_ptr) >= 0) && ((unsigned long) (private_ptr) + (sizeof(*private_ptr)) <= 0) && ((unsigned long) (private_ptr) + (sizeof(*private_ptr)) >= (unsigned long)(private_ptr))) || (((current_thread_info()->addr_limit)).seg == (((mm_segment_t) { (0xFFFFFFFF) })).seg))) ? ({ __typeof__(*(private_ptr)) *__private_ptr = private_ptr; __typeof__(*(__private_ptr)) __private_val; int __private_ret = -14; __private_val = (__typeof__(*(__private_ptr))) (task_pid_vnr((current_thread_info()->task))); if (copy_to_user((__private_ptr), &__private_val, sizeof(*(__private_ptr))) == 0) { __private_ret = 0; } __private_ret; }) : -14); });
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>context_switch(struct rq *rq, struct task_struct *prev,
>        struct task_struct *next)
>{
> struct mm_struct *mm, *oldmm;
>
> prepare_task_switch(rq, prev, next);
> mm = next->mm;
> oldmm = prev->active_mm;
>
>
>
>
>
> do {} while (0);
>
> if (__builtin_expect(!!(!mm), 0)) {
>  next->active_mm = oldmm;
>  atomic_inc(&oldmm->mm_count);
>  enter_lazy_tlb(oldmm, next);
> } else
>  switch_mm(oldmm, mm, next);
>
> if (__builtin_expect(!!(!prev->mm), 0)) {
>  prev->active_mm = ((void *)0);
>  rq->prev_mm = oldmm;
> }
>
>
>
>
>
>
>
> do { } while (0);
>
>
>
> prev = _switch_to(prev, next, prev);
>
> __asm__ __volatile__("": : :"memory");
>
>
>
>
>
> finish_task_switch((&per_cpu__runqueues), prev);
>}
># 2493 "kernel/sched.c"
>unsigned long nr_running(void)
>{
> unsigned long i, sum = 0;
>
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_online_map)
>  sum += (&(*((void)((i)), &per_cpu__runqueues)))->nr_running;
>
> return sum;
>}
>
>unsigned long nr_uninterruptible(void)
>{
> unsigned long i, sum = 0;
>
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_possible_map)
>  sum += (&(*((void)((i)), &per_cpu__runqueues)))->nr_uninterruptible;
>
>
>
>
>
> if (__builtin_expect(!!((long)sum < 0), 0))
>  sum = 0;
>
> return sum;
>}
>
>unsigned long long nr_context_switches(void)
>{
> int i;
> unsigned long long sum = 0;
>
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_possible_map)
>  sum += (&(*((void)((i)), &per_cpu__runqueues)))->nr_switches;
>
> return sum;
>}
>
>unsigned long nr_iowait(void)
>{
> unsigned long i, sum = 0;
>
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_possible_map)
>  sum += ((&(&(*((void)((i)), &per_cpu__runqueues)))->nr_iowait)->counter);
>
> return sum;
>}
>
>unsigned long nr_active(void)
>{
> unsigned long i, running = 0, uninterruptible = 0;
>
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_online_map) {
>  running += (&(*((void)((i)), &per_cpu__runqueues)))->nr_running;
>  uninterruptible += (&(*((void)((i)), &per_cpu__runqueues)))->nr_uninterruptible;
> }
>
> if (__builtin_expect(!!((long)uninterruptible < 0), 0))
>  uninterruptible = 0;
>
> return running + uninterruptible;
>}
>
>
>
>
>
>static void update_cpu_load(struct rq *this_rq)
>{
> unsigned long this_load = this_rq->load.weight;
> int i, scale;
>
> this_rq->nr_load_updates++;
>
>
> for (i = 0, scale = 1; i < 5; i++, scale += scale) {
>  unsigned long old_load, new_load;
>
>
>
>  old_load = this_rq->cpu_load[i];
>  new_load = this_load;
>
>
>
>
>
>  if (new_load > old_load)
>   new_load += scale-1;
>  this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) >> i;
> }
>}
># 3837 "kernel/sched.c"
>static inline __attribute__((always_inline)) void idle_balance(int cpu, struct rq *rq)
>{
>}
>
>
>
> __typeof__(struct kernel_stat) per_cpu__kstat;
>
>extern typeof(per_cpu__kstat) per_cpu__kstat; static const char __kstrtab_per_cpu__kstat[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "per_cpu__kstat"; static const struct kernel_symbol __ksymtab_per_cpu__kstat __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&per_cpu__kstat, __kstrtab_per_cpu__kstat };
>
>
>
>
>
>unsigned long long task_sched_runtime(struct task_struct *p)
>{
> unsigned long flags;
> u64 ns, delta_exec;
> struct rq *rq;
>
> rq = task_rq_lock(p, &flags);
> ns = p->se.sum_exec_runtime;
> if (task_current(rq, p)) {
>  update_rq_clock(rq);
>  delta_exec = rq->clock - p->se.exec_start;
>  if ((s64)delta_exec > 0)
>   ns += delta_exec;
> }
> task_rq_unlock(rq, &flags);
>
> return ns;
>}
>
>
>
>
>
>
>void account_user_time(struct task_struct *p, cputime_t cputime)
>{
> struct cpu_usage_stat *cpustat = &per_cpu__kstat.cpustat;
> cputime64_t tmp;
>
> p->utime = ((p->utime) + (cputime));
>
>
> tmp = ((u64) cputime);
> if ((((p)->static_prio) - 100 - 20) > 0)
>  cpustat->nice = ((cpustat->nice) + (tmp));
> else
>  cpustat->user = ((cpustat->user) + (tmp));
>}
>
>
>
>
>
>
>static void account_guest_time(struct task_struct *p, cputime_t cputime)
>{
> cputime64_t tmp;
> struct cpu_usage_stat *cpustat = &per_cpu__kstat.cpustat;
>
> tmp = ((u64) cputime);
>
> p->utime = ((p->utime) + (cputime));
> p->gtime = ((p->gtime) + (cputime));
>
> cpustat->user = ((cpustat->user) + (tmp));
> cpustat->guest = ((cpustat->guest) + (tmp));
>}
>
>
>
>
>
>
>void account_user_time_scaled(struct task_struct *p, cputime_t cputime)
>{
> p->utimescaled = ((p->utimescaled) + (cputime));
>}
>
>
>
>
>
>
>
>void account_system_time(struct task_struct *p, int hardirq_offset,
>    cputime_t cputime)
>{
> struct cpu_usage_stat *cpustat = &per_cpu__kstat.cpustat;
> struct rq *rq = (&per_cpu__runqueues);
> cputime64_t tmp;
>
> if ((p->flags & 0x00000010) && (((current_thread_info()->preempt_count) & ((((1UL << (12))-1) << ((0 + 8) + 8)) | (((1UL << (8))-1) << (0 + 8)))) - hardirq_offset == 0)) {
>  account_guest_time(p, cputime);
>  return;
> }
>
> p->stime = ((p->stime) + (cputime));
>
>
> tmp = ((u64) cputime);
> if (((current_thread_info()->preempt_count) & (((1UL << (12))-1) << ((0 + 8) + 8))) - hardirq_offset)
>  cpustat->irq = ((cpustat->irq) + (tmp));
> else if (((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))
>  cpustat->softirq = ((cpustat->softirq) + (tmp));
> else if (p != rq->idle)
>  cpustat->system = ((cpustat->system) + (tmp));
> else if (((&rq->nr_iowait)->counter) > 0)
>  cpustat->iowait = ((cpustat->iowait) + (tmp));
> else
>  cpustat->idle = ((cpustat->idle) + (tmp));
>
> acct_update_integrals(p);
>}
>
>
>
>
>
>
>
>void account_system_time_scaled(struct task_struct *p, cputime_t cputime)
>{
> p->stimescaled = ((p->stimescaled) + (cputime));
>}
>
>
>
>
>
>
>void account_steal_time(struct task_struct *p, cputime_t steal)
>{
> struct cpu_usage_stat *cpustat = &per_cpu__kstat.cpustat;
> cputime64_t tmp = ((u64) steal);
> struct rq *rq = (&per_cpu__runqueues);
>
> if (p == rq->idle) {
>  p->stime = ((p->stime) + (steal));
>  if (((&rq->nr_iowait)->counter) > 0)
>   cpustat->iowait = ((cpustat->iowait) + (tmp));
>  else
>   cpustat->idle = ((cpustat->idle) + (tmp));
> } else
>  cpustat->steal = ((cpustat->steal) + (tmp));
>}
># 3994 "kernel/sched.c"
>void scheduler_tick(void)
>{
> int cpu = 0;
> struct rq *rq = (&(*((void)((cpu)), &per_cpu__runqueues)));
> struct task_struct *curr = rq->curr;
>
> sched_clock_tick();
>
> do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
> update_rq_clock(rq);
> update_cpu_load(rq);
> curr->sched_class->task_tick(rq, curr, 0);
> do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
>
>
>
>
>
>}
># 4055 "kernel/sched.c"
>static __attribute__((noinline)) void __schedule_bug(struct task_struct *prev)
>{
> struct pt_regs *regs = get_irq_regs();
>
> printk("<3>" "BUG: scheduling while atomic: %s/%d/0x%08x\n",
>  prev->comm, prev->pid, (current_thread_info()->preempt_count));
>
> debug_show_held_locks(prev);
> if (({ unsigned long flags; do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); (flags == 0); }))
>  print_irqtrace_events(prev);
>
> if (regs)
>  show_regs(regs);
> else
>  dump_stack();
>}
>
>
>
>
>static inline __attribute__((always_inline)) void schedule_debug(struct task_struct *prev)
>{
>
>
>
>
>
> if (__builtin_expect(!!((((current_thread_info()->preempt_count) & ~0x10000000) != 0) && !prev->exit_state), 0))
>  __schedule_bug(prev);
>
> profile_hit(2, __builtin_return_address(0));
>
> do { } while (0);
>
>
>
>
>
>
>}
>
>
>
>
>static inline __attribute__((always_inline)) struct task_struct *
>pick_next_task(struct rq *rq, struct task_struct *prev)
>{
> const struct sched_class *class;
> struct task_struct *p;
>
>
>
>
>
> if (__builtin_expect(!!(rq->nr_running == rq->cfs.nr_running), 1)) {
>  p = fair_sched_class.pick_next_task(rq);
>  if (__builtin_expect(!!(p), 1))
>   return p;
> }
>
> class = (&rt_sched_class);
> for ( ; ; ) {
>  p = class->pick_next_task(rq);
>  if (p)
>   return p;
>
>
>
>
>  class = class->next;
> }
>}
>
>
>
>
> void __attribute__((__section__(".sched.text"))) schedule(void)
>{
> struct task_struct *prev, *next;
> unsigned long *switch_count;
> struct rq *rq;
> int cpu;
>
>need_resched:
> do { } while (0);
> cpu = 0;
> rq = (&(*((void)((cpu)), &per_cpu__runqueues)));
> rcu_qsctr_inc(cpu);
> prev = rq->curr;
> switch_count = &prev->nivcsw;
>
> do { } while(0);
>need_resched_nonpreemptible:
>
> schedule_debug(prev);
>
> hrtick_clear(rq);
>
>
>
>
> block_signals();
> update_rq_clock(rq);
> do { do { } while (0); (void)0; (void)(&rq->lock); } while (0);
> clear_tsk_need_resched(prev);
>
> if (prev->state && !((current_thread_info()->preempt_count) & 0x10000000)) {
>  if (__builtin_expect(!!((prev->state & 1) && signal_pending(prev)), 0)) {
>
>   prev->state = 0;
>  } else {
>   deactivate_task(rq, prev, 1);
>  }
>  switch_count = &prev->nvcsw;
> }
>
>
>
>
>
>
> if (__builtin_expect(!!(!rq->nr_running), 0))
>  idle_balance(cpu, rq);
>
> prev->sched_class->put_prev_task(rq, prev);
> next = pick_next_task(rq, prev);
>
> if (__builtin_expect(!!(prev != next), 1)) {
>  do { } while (0);
>
>  rq->nr_switches++;
>  rq->curr = next;
>  ++*switch_count;
>
>  context_switch(rq, prev, next);
>
>
>
>
>  cpu = 0;
>  rq = (&(*((void)((cpu)), &per_cpu__runqueues)));
> } else
>  do { unblock_signals(); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
>
> hrtick_set(rq);
>
> if (__builtin_expect(!!(0 < 0), 0))
>  goto need_resched_nonpreemptible;
>
> do { } while (0);
> if (__builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 2)), 0))
>  goto need_resched;
>}
>extern typeof(schedule) schedule; static const char __kstrtab_schedule[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "schedule"; static const struct kernel_symbol __ksymtab_schedule __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&schedule, __kstrtab_schedule };
># 4271 "kernel/sched.c"
>int default_wake_function(wait_queue_t *curr, unsigned mode, int sync,
>     void *key)
>{
> return try_to_wake_up(curr->private, mode, sync);
>}
>extern typeof(default_wake_function) default_wake_function; static const char __kstrtab_default_wake_function[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "default_wake_function"; static const struct kernel_symbol __ksymtab_default_wake_function __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&default_wake_function, __kstrtab_default_wake_function };
># 4287 "kernel/sched.c"
>static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
>        int nr_exclusive, int sync, void *key)
>{
> wait_queue_t *curr, *next;
>
> for (curr = ({ const typeof( ((typeof(*curr) *)0)->task_list ) *__mptr = ((&q->task_list)->next); (typeof(*curr) *)( (char *)__mptr - __builtin_offsetof(typeof(*curr),task_list) );}), next = ({ const typeof( ((typeof(*curr) *)0)->task_list ) *__mptr = (curr->task_list.next); (typeof(*curr) *)( (char *)__mptr - __builtin_offsetof(typeof(*curr),task_list) );}); &curr->task_list != (&q->task_list); curr = next, next = ({ const typeof( ((typeof(*next) *)0)->task_list ) *__mptr = (next->task_list.next); (typeof(*next) *)( (char *)__mptr - __builtin_offsetof(typeof(*next),task_list) );})) {
>  unsigned flags = curr->flags;
>
>  if (curr->func(curr, mode, sync, key) &&
>    (flags & 0x01) && !--nr_exclusive)
>   break;
> }
>}
># 4308 "kernel/sched.c"
>void __wake_up(wait_queue_head_t *q, unsigned int mode,
>   int nr_exclusive, void *key)
>{
> unsigned long flags;
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
> __wake_up_common(q, mode, nr_exclusive, 0, key);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
>}
>extern typeof(__wake_up) __wake_up; static const char __kstrtab___wake_up[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "__wake_up"; static const struct kernel_symbol __ksymtab___wake_up __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&__wake_up, __kstrtab___wake_up };
>
>
>
>
>void __wake_up_locked(wait_queue_head_t *q, unsigned int mode)
>{
> __wake_up_common(q, mode, 1, 0, ((void *)0));
>}
># 4340 "kernel/sched.c"
>void
>__wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
>{
> unsigned long flags;
> int sync = 1;
>
> if (__builtin_expect(!!(!q), 0))
>  return;
>
> if (__builtin_expect(!!(!nr_exclusive), 0))
>  sync = 0;
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
> __wake_up_common(q, mode, nr_exclusive, sync, ((void *)0));
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
>}
>extern typeof(__wake_up_sync) __wake_up_sync; static const char __kstrtab___wake_up_sync[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "__wake_up_sync"; static const struct kernel_symbol __ksymtab___wake_up_sync __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&__wake_up_sync, __kstrtab___wake_up_sync };
>
>void complete(struct completion *x)
>{
> unsigned long flags;
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
> x->done++;
> __wake_up_common(&x->wait, (1 | 2), 1, 0, ((void *)0));
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
>}
>extern typeof(complete) complete; static const char __kstrtab_complete[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "complete"; static const struct kernel_symbol __ksymtab_complete __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&complete, __kstrtab_complete };
>
>void complete_all(struct completion *x)
>{
> unsigned long flags;
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
> x->done += (~0U)/2;
> __wake_up_common(&x->wait, (1 | 2), 0, 0, ((void *)0));
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
>}
>extern typeof(complete_all) complete_all; static const char __kstrtab_complete_all[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "complete_all"; static const struct kernel_symbol __ksymtab_complete_all __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&complete_all, __kstrtab_complete_all };
>
>static inline __attribute__((always_inline)) long __attribute__((__section__(".sched.text")))
>do_wait_for_common(struct completion *x, long timeout, int state)
>{
> if (!x->done) {
>  wait_queue_t wait = { .private = (current_thread_info()->task), .func = default_wake_function, .task_list = { ((void *)0), ((void *)0) } };
>
>  wait.flags |= 0x01;
>  __add_wait_queue_tail(&x->wait, &wait);
>  do {
>   if ((state == 1 &&
>        signal_pending((current_thread_info()->task))) ||
>       (state == (128 | 2) &&
>        fatal_signal_pending((current_thread_info()->task)))) {
>    __remove_wait_queue(&x->wait, &wait);
>    return -512;
>   }
>   do { (current_thread_info()->task)->state = (state); } while (0);
>   do { unblock_signals(); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
>   timeout = schedule_timeout(timeout);
>   do { block_signals(); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
>   if (!timeout) {
>    __remove_wait_queue(&x->wait, &wait);
>    return timeout;
>   }
>  } while (!x->done);
>  __remove_wait_queue(&x->wait, &wait);
> }
> x->done--;
> return timeout;
>}
>
>static long __attribute__((__section__(".sched.text")))
>wait_for_common(struct completion *x, long timeout, int state)
>{
> do { do { } while (0); } while (0);
>
> do { block_signals(); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
> timeout = do_wait_for_common(x, timeout, state);
> do { unblock_signals(); do { do { } while (0); (void)0; (void)(&x->wait.lock); } while (0); } while (0);
> return timeout;
>}
>
>void __attribute__((__section__(".sched.text"))) wait_for_completion(struct completion *x)
>{
> wait_for_common(x, ((long)(~0UL>>1)), 2);
>}
>extern typeof(wait_for_completion) wait_for_completion; static const char __kstrtab_wait_for_completion[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "wait_for_completion"; static const struct kernel_symbol __ksymtab_wait_for_completion __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&wait_for_completion, __kstrtab_wait_for_completion };
>
>unsigned long __attribute__((__section__(".sched.text")))
>wait_for_completion_timeout(struct completion *x, unsigned long timeout)
>{
> return wait_for_common(x, timeout, 2);
>}
>extern typeof(wait_for_completion_timeout) wait_for_completion_timeout; static const char __kstrtab_wait_for_completion_timeout[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "wait_for_completion_timeout"; static const struct kernel_symbol __ksymtab_wait_for_completion_timeout __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&wait_for_completion_timeout, __kstrtab_wait_for_completion_timeout };
>
>int __attribute__((__section__(".sched.text"))) wait_for_completion_interruptible(struct completion *x)
>{
> long t = wait_for_common(x, ((long)(~0UL>>1)), 1);
> if (t == -512)
>  return t;
> return 0;
>}
>extern typeof(wait_for_completion_interruptible) wait_for_completion_interruptible; static const char __kstrtab_wait_for_completion_interruptible[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "wait_for_completion_interruptible"; static const struct kernel_symbol __ksymtab_wait_for_completion_interruptible __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&wait_for_completion_interruptible, __kstrtab_wait_for_completion_interruptible };
>
>unsigned long __attribute__((__section__(".sched.text")))
>wait_for_completion_interruptible_timeout(struct completion *x,
>       unsigned long timeout)
>{
> return wait_for_common(x, timeout, 1);
>}
>extern typeof(wait_for_completion_interruptible_timeout) wait_for_completion_interruptible_timeout; static const char __kstrtab_wait_for_completion_interruptible_timeout[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "wait_for_completion_interruptible_timeout"; static const struct kernel_symbol __ksymtab_wait_for_completion_interruptible_timeout __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&wait_for_completion_interruptible_timeout, __kstrtab_wait_for_completion_interruptible_timeout };
>
>int __attribute__((__section__(".sched.text"))) wait_for_completion_killable(struct completion *x)
>{
> long t = wait_for_common(x, ((long)(~0UL>>1)), (128 | 2));
> if (t == -512)
>  return t;
> return 0;
>}
>extern typeof(wait_for_completion_killable) wait_for_completion_killable; static const char __kstrtab_wait_for_completion_killable[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "wait_for_completion_killable"; static const struct kernel_symbol __ksymtab_wait_for_completion_killable __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&wait_for_completion_killable, __kstrtab_wait_for_completion_killable };
>
>static long __attribute__((__section__(".sched.text")))
>sleep_on_common(wait_queue_head_t *q, int state, long timeout)
>{
> unsigned long flags;
> wait_queue_t wait;
>
> init_waitqueue_entry(&wait, (current_thread_info()->task));
>
> do { (current_thread_info()->task)->state = (state); } while (0);
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
> __add_wait_queue(q, &wait);
> do { do { } while (0); (void)0; (void)(&q->lock); } while (0);
> timeout = schedule_timeout(timeout);
> do { block_signals(); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
> __remove_wait_queue(q, &wait);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&q->lock); } while (0); } while (0);
>
> return timeout;
>}
>
>void __attribute__((__section__(".sched.text"))) interruptible_sleep_on(wait_queue_head_t *q)
>{
> sleep_on_common(q, 1, ((long)(~0UL>>1)));
>}
>extern typeof(interruptible_sleep_on) interruptible_sleep_on; static const char __kstrtab_interruptible_sleep_on[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "interruptible_sleep_on"; static const struct kernel_symbol __ksymtab_interruptible_sleep_on __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&interruptible_sleep_on, __kstrtab_interruptible_sleep_on };
>
>long __attribute__((__section__(".sched.text")))
>interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
>{
> return sleep_on_common(q, 1, timeout);
>}
>extern typeof(interruptible_sleep_on_timeout) interruptible_sleep_on_timeout; static const char __kstrtab_interruptible_sleep_on_timeout[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "interruptible_sleep_on_timeout"; static const struct kernel_symbol __ksymtab_interruptible_sleep_on_timeout __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&interruptible_sleep_on_timeout, __kstrtab_interruptible_sleep_on_timeout };
>
>void __attribute__((__section__(".sched.text"))) sleep_on(wait_queue_head_t *q)
>{
> sleep_on_common(q, 2, ((long)(~0UL>>1)));
>}
>extern typeof(sleep_on) sleep_on; static const char __kstrtab_sleep_on[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "sleep_on"; static const struct kernel_symbol __ksymtab_sleep_on __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&sleep_on, __kstrtab_sleep_on };
>
>long __attribute__((__section__(".sched.text"))) sleep_on_timeout(wait_queue_head_t *q, long timeout)
>{
> return sleep_on_common(q, 2, timeout);
>}
>extern typeof(sleep_on_timeout) sleep_on_timeout; static const char __kstrtab_sleep_on_timeout[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "sleep_on_timeout"; static const struct kernel_symbol __ksymtab_sleep_on_timeout __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&sleep_on_timeout, __kstrtab_sleep_on_timeout };
># 4519 "kernel/sched.c"
>void rt_mutex_setprio(struct task_struct *p, int prio)
>{
> unsigned long flags;
> int oldprio, on_rq, running;
> struct rq *rq;
> const struct sched_class *prev_class = p->sched_class;
>
> do { if (__builtin_expect(!!(prio < 0 || prio > (100 + 40)), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched.c", 4526, (__func__)); panic("BUG!"); } while (0); } while(0);
>
> rq = task_rq_lock(p, &flags);
> update_rq_clock(rq);
>
> oldprio = p->prio;
> on_rq = p->se.on_rq;
> running = task_current(rq, p);
> if (on_rq)
>  dequeue_task(rq, p, 0);
> if (running)
>  p->sched_class->put_prev_task(rq, p);
>
> if (rt_prio(prio))
>  p->sched_class = &rt_sched_class;
> else
>  p->sched_class = &fair_sched_class;
>
> p->prio = prio;
>
> if (running)
>  p->sched_class->set_curr_task(rq);
> if (on_rq) {
>  enqueue_task(rq, p, 0);
>
>  check_class_changed(rq, p, prev_class, oldprio, running);
> }
> task_rq_unlock(rq, &flags);
>}
>
>
>
>void set_user_nice(struct task_struct *p, long nice)
>{
> int old_prio, delta, on_rq;
> unsigned long flags;
> struct rq *rq;
>
> if ((((p)->static_prio) - 100 - 20) == nice || nice < -20 || nice > 19)
>  return;
>
>
>
>
> rq = task_rq_lock(p, &flags);
> update_rq_clock(rq);
>
>
>
>
>
>
> if (task_has_rt_policy(p)) {
>  p->static_prio = (100 + (nice) + 20);
>  goto out_unlock;
> }
> on_rq = p->se.on_rq;
> if (on_rq) {
>  dequeue_task(rq, p, 0);
>  dec_load(rq, p);
> }
>
> p->static_prio = (100 + (nice) + 20);
> set_load_weight(p);
> old_prio = p->prio;
> p->prio = effective_prio(p);
> delta = p->prio - old_prio;
>
> if (on_rq) {
>  enqueue_task(rq, p, 0);
>  inc_load(rq, p);
>
>
>
>
>  if (delta < 0 || (delta > 0 && task_running(rq, p)))
>   resched_task(rq->curr);
> }
>out_unlock:
> task_rq_unlock(rq, &flags);
>}
>extern typeof(set_user_nice) set_user_nice; static const char __kstrtab_set_user_nice[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "set_user_nice"; static const struct kernel_symbol __ksymtab_set_user_nice __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&set_user_nice, __kstrtab_set_user_nice };
>
>
>
>
>
>
>int can_nice(const struct task_struct *p, const int nice)
>{
>
> int nice_rlim = 20 - nice;
>
> return (nice_rlim <= p->signal->rlim[13].rlim_cur ||
>  capable(23));
>}
># 4632 "kernel/sched.c"
> long sys_nice(int increment)
>{
> long nice, retval;
>
>
>
>
>
>
> if (increment < -40)
>  increment = -40;
> if (increment > 40)
>  increment = 40;
>
> nice = (((current_thread_info()->task)->static_prio) - 100 - 20) + increment;
> if (nice < -20)
>  nice = -20;
> if (nice > 19)
>  nice = 19;
>
> if (increment < 0 && !can_nice((current_thread_info()->task), nice))
>  return -1;
>
> retval = security_task_setnice((current_thread_info()->task), nice);
> if (retval)
>  return retval;
>
> set_user_nice((current_thread_info()->task), nice);
> return 0;
>}
># 4673 "kernel/sched.c"
>int task_prio(const struct task_struct *p)
>{
> return p->prio - 100;
>}
>
>
>
>
>
>int task_nice(const struct task_struct *p)
>{
> return (((p)->static_prio) - 100 - 20);
>}
>extern typeof(task_nice) task_nice; static const char __kstrtab_task_nice[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "task_nice"; static const struct kernel_symbol __ksymtab_task_nice __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&task_nice, __kstrtab_task_nice };
>
>
>
>
>
>int idle_cpu(int cpu)
>{
> return ((&(*((void)((cpu)), &per_cpu__runqueues)))->curr) == (&(*((void)((cpu)), &per_cpu__runqueues)))->idle;
>}
>
>
>
>
>
>struct task_struct *idle_task(int cpu)
>{
> return (&(*((void)((cpu)), &per_cpu__runqueues)))->idle;
>}
>
>
>
>
>
>static struct task_struct *find_process_by_pid(pid_t pid)
>{
> return pid ? find_task_by_vpid(pid) : (current_thread_info()->task);
>}
>
>
>static void
>__setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
>{
> do { if (__builtin_expect(!!(p->se.on_rq), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched.c", 4719, (__func__)); panic("BUG!"); } while (0); } while(0);
>
> p->policy = policy;
> switch (p->policy) {
> case 0:
> case 3:
> case 5:
>  p->sched_class = &fair_sched_class;
>  break;
> case 1:
> case 2:
>  p->sched_class = &rt_sched_class;
>  break;
> }
>
> p->rt_priority = prio;
> p->normal_prio = normal_prio(p);
>
> p->prio = rt_mutex_getprio(p);
> set_load_weight(p);
>}
># 4749 "kernel/sched.c"
>int sched_setscheduler(struct task_struct *p, int policy,
>         struct sched_param *param)
>{
> int retval, oldprio, oldpolicy = -1, on_rq, running;
> unsigned long flags;
> const struct sched_class *prev_class = p->sched_class;
> struct rq *rq;
>
>
> do { if (__builtin_expect(!!((((current_thread_info()->preempt_count) & ((((1UL << (12))-1) << ((0 + 8) + 8)) | (((1UL << (8))-1) << (0 + 8)))))), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched.c", 4758, (__func__)); panic("BUG!"); } while (0); } while(0);
>recheck:
>
> if (policy < 0)
>  policy = oldpolicy = p->policy;
> else if (policy != 1 && policy != 2 &&
>   policy != 0 && policy != 3 &&
>   policy != 5)
>  return -22;
>
>
>
>
>
> if (param->sched_priority < 0 ||
>     (p->mm && param->sched_priority > 100 -1) ||
>     (!p->mm && param->sched_priority > 100 -1))
>  return -22;
> if (rt_policy(policy) != (param->sched_priority != 0))
>  return -22;
>
>
>
>
> if (!capable(23)) {
>  if (rt_policy(policy)) {
>   unsigned long rlim_rtprio;
>
>   if (!lock_task_sighand(p, &flags))
>    return -3;
>   rlim_rtprio = p->signal->rlim[14].rlim_cur;
>   unlock_task_sighand(p, &flags);
>
>
>   if (policy != p->policy && !rlim_rtprio)
>    return -1;
>
>
>   if (param->sched_priority > p->rt_priority &&
>       param->sched_priority > rlim_rtprio)
>    return -1;
>  }
>
>
>
>
>  if (p->policy == 5 && policy != 5)
>   return -1;
>
>
>  if (((current_thread_info()->task)->euid != p->euid) &&
>      ((current_thread_info()->task)->euid != p->uid))
>   return -1;
> }
># 4822 "kernel/sched.c"
> retval = security_task_setscheduler(p, policy, param);
> if (retval)
>  return retval;
>
>
>
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&p->pi_lock); } while (0); } while (0);
>
>
>
>
> rq = __task_rq_lock(p);
>
> if (__builtin_expect(!!(oldpolicy != -1 && oldpolicy != p->policy), 0)) {
>  policy = oldpolicy = -1;
>  __task_rq_unlock(rq);
>  do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&p->pi_lock); } while (0); } while (0);
>  goto recheck;
> }
> update_rq_clock(rq);
> on_rq = p->se.on_rq;
> running = task_current(rq, p);
> if (on_rq)
>  deactivate_task(rq, p, 0);
> if (running)
>  p->sched_class->put_prev_task(rq, p);
>
> oldprio = p->prio;
> __setscheduler(rq, p, policy, param->sched_priority);
>
> if (running)
>  p->sched_class->set_curr_task(rq);
> if (on_rq) {
>  activate_task(rq, p, 0);
>
>  check_class_changed(rq, p, prev_class, oldprio, running);
> }
> __task_rq_unlock(rq);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&p->pi_lock); } while (0); } while (0);
>
> rt_mutex_adjust_pi(p);
>
> return 0;
>}
>extern typeof(sched_setscheduler) sched_setscheduler; static const char __kstrtab_sched_setscheduler[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "sched_setscheduler"; static const struct kernel_symbol __ksymtab_sched_setscheduler __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&sched_setscheduler, __kstrtab_sched_setscheduler };
>
>static int
>do_sched_setscheduler(pid_t pid, int policy, struct sched_param *param)
>{
> struct sched_param lparam;
> struct task_struct *p;
> int retval;
>
> if (!param || pid < 0)
>  return -22;
> if (copy_from_user(&lparam, param, sizeof(struct sched_param)))
>  return -14;
>
> do { do { } while (0); (void)0; do { } while (0); } while (0);
> retval = -3;
> p = find_process_by_pid(pid);
> if (p != ((void *)0))
>  retval = sched_setscheduler(p, policy, &lparam);
> do { do { } while (0); (void)0; do { } while (0); } while (0);
>
> return retval;
>}
>
>
>
>
>
>
>
> long
>sys_sched_setscheduler(pid_t pid, int policy, struct sched_param *param)
>{
>
> if (policy < 0)
>  return -22;
>
> return do_sched_setscheduler(pid, policy, param);
>}
>
>
>
>
>
>
> long sys_sched_setparam(pid_t pid, struct sched_param *param)
>{
> return do_sched_setscheduler(pid, -1, param);
>}
>
>
>
>
>
> long sys_sched_getscheduler(pid_t pid)
>{
> struct task_struct *p;
> int retval;
>
> if (pid < 0)
>  return -22;
>
> retval = -3;
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> p = find_process_by_pid(pid);
> if (p) {
>  retval = security_task_getscheduler(p);
>  if (!retval)
>   retval = p->policy;
> }
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> return retval;
>}
>
>
>
>
>
>
> long sys_sched_getparam(pid_t pid, struct sched_param *param)
>{
> struct sched_param lp;
> struct task_struct *p;
> int retval;
>
> if (!param || pid < 0)
>  return -22;
>
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> p = find_process_by_pid(pid);
> retval = -3;
> if (!p)
>  goto out_unlock;
>
> retval = security_task_getscheduler(p);
> if (retval)
>  goto out_unlock;
>
> lp.sched_priority = p->rt_priority;
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
>
>
>
>
> retval = copy_to_user(param, &lp, sizeof(*param)) ? -14 : 0;
>
> return retval;
>
>out_unlock:
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> return retval;
>}
>
>long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
>{
> cpumask_t cpus_allowed;
> cpumask_t new_mask = *in_mask;
> struct task_struct *p;
> int retval;
>
> do { } while (0);
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
>
> p = find_process_by_pid(pid);
> if (!p) {
>  do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
>  do { } while (0);
>  return -3;
> }
>
>
>
>
>
>
> do { atomic_inc(&(p)->usage); } while(0);
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
>
> retval = -1;
> if (((current_thread_info()->task)->euid != p->euid) && ((current_thread_info()->task)->euid != p->uid) &&
>   !capable(23))
>  goto out_unlock;
>
> retval = security_task_setscheduler(p, 0, ((void *)0));
> if (retval)
>  goto out_unlock;
>
> cpuset_cpus_allowed(p, &cpus_allowed);
> __cpus_and(&(new_mask), &(new_mask), &(cpus_allowed), 1);
> again:
> retval = set_cpus_allowed_ptr(p, &new_mask);
>
> if (!retval) {
>  cpuset_cpus_allowed(p, &cpus_allowed);
>  if (!__cpus_subset(&(new_mask), &(cpus_allowed), 1)) {
>
>
>
>
>
>   new_mask = cpus_allowed;
>   goto again;
>  }
> }
>out_unlock:
> put_task_struct(p);
> do { } while (0);
> return retval;
>}
>
>static int get_user_cpu_mask(unsigned long *user_mask_ptr, unsigned len,
>        cpumask_t *new_mask)
>{
> if (len < sizeof(cpumask_t)) {
>  memset(new_mask, 0, sizeof(cpumask_t));
> } else if (len > sizeof(cpumask_t)) {
>  len = sizeof(cpumask_t);
> }
> return copy_from_user(new_mask, user_mask_ptr, len) ? -14 : 0;
>}
>
>
>
>
>
>
>
> long sys_sched_setaffinity(pid_t pid, unsigned int len,
>          unsigned long *user_mask_ptr)
>{
> cpumask_t new_mask;
> int retval;
>
> retval = get_user_cpu_mask(user_mask_ptr, len, &new_mask);
> if (retval)
>  return retval;
>
> return sched_setaffinity(pid, &new_mask);
>}
># 5074 "kernel/sched.c"
>cpumask_t cpu_present_map ;
>extern typeof(cpu_present_map) cpu_present_map; static const char __kstrtab_cpu_present_map[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "cpu_present_map"; static const struct kernel_symbol __ksymtab_cpu_present_map __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&cpu_present_map, __kstrtab_cpu_present_map };
>
>
>cpumask_t cpu_online_map = (cpumask_t) { { [(((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))-1] = ( ((1) % 64) ? (1UL<<((1) % 64))-1 : ~0UL ) } };
>extern typeof(cpu_online_map) cpu_online_map; static const char __kstrtab_cpu_online_map[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "cpu_online_map"; static const struct kernel_symbol __ksymtab_cpu_online_map __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&cpu_online_map, __kstrtab_cpu_online_map };
>
>cpumask_t cpu_possible_map = (cpumask_t) { { [(((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))-1] = ( ((1) % 64) ? (1UL<<((1) % 64))-1 : ~0UL ) } };
>extern typeof(cpu_possible_map) cpu_possible_map; static const char __kstrtab_cpu_possible_map[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "cpu_possible_map"; static const struct kernel_symbol __ksymtab_cpu_possible_map __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&cpu_possible_map, __kstrtab_cpu_possible_map };
>
>
>long sched_getaffinity(pid_t pid, cpumask_t *mask)
>{
> struct task_struct *p;
> int retval;
>
> do { } while (0);
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
>
> retval = -3;
> p = find_process_by_pid(pid);
> if (!p)
>  goto out_unlock;
>
> retval = security_task_getscheduler(p);
> if (retval)
>  goto out_unlock;
>
> __cpus_and(&(*mask), &(p->cpus_allowed), &(cpu_online_map), 1);
>
>out_unlock:
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> do { } while (0);
>
> return retval;
>}
>
>
>
>
>
>
>
> long sys_sched_getaffinity(pid_t pid, unsigned int len,
>          unsigned long *user_mask_ptr)
>{
> int ret;
> cpumask_t mask;
>
> if (len < sizeof(cpumask_t))
>  return -22;
>
> ret = sched_getaffinity(pid, &mask);
> if (ret < 0)
>  return ret;
>
> if (copy_to_user(user_mask_ptr, &mask, sizeof(cpumask_t)))
>  return -14;
>
> return sizeof(cpumask_t);
>}
>
>
>
>
>
>
>
> long sys_sched_yield(void)
>{
> struct rq *rq = this_rq_lock();
>
> do { } while (0);
> (current_thread_info()->task)->sched_class->yield_task(rq);
>
>
>
>
>
> (void)0;
> do { } while (0);
> do { (void)(&(&rq->lock)->raw_lock); } while (0);
> do { } while (0);
>
> schedule();
>
> return 0;
>}
>
>static void __cond_resched(void)
>{
># 5173 "kernel/sched.c"
> do {
>  do { (current_thread_info()->preempt_count) += (0x10000000); } while (0);
>  schedule();
>  do { (current_thread_info()->preempt_count) -= (0x10000000); } while (0);
> } while (need_resched());
>}
>
>int __attribute__((__section__(".sched.text"))) _cond_resched(void)
>{
> if (need_resched() && !((current_thread_info()->preempt_count) & 0x10000000) &&
>     system_state == SYSTEM_RUNNING) {
>  __cond_resched();
>  return 1;
> }
> return 0;
>}
>extern typeof(_cond_resched) _cond_resched; static const char __kstrtab__cond_resched[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "_cond_resched"; static const struct kernel_symbol __ksymtab__cond_resched __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&_cond_resched, __kstrtab__cond_resched };
># 5199 "kernel/sched.c"
>int cond_resched_lock(spinlock_t *lock)
>{
> int resched = need_resched() && system_state == SYSTEM_RUNNING;
> int ret = 0;
>
> if (spin_needbreak(lock) || resched) {
>  do { do { } while (0); (void)0; (void)(lock); } while (0);
>  if (resched && need_resched())
>   __cond_resched();
>  else
>   rep_nop();
>  ret = 1;
>  do { do { } while (0); (void)0; (void)(lock); } while (0);
> }
> return ret;
>}
>extern typeof(cond_resched_lock) cond_resched_lock; static const char __kstrtab_cond_resched_lock[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "cond_resched_lock"; static const struct kernel_symbol __ksymtab_cond_resched_lock __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&cond_resched_lock, __kstrtab_cond_resched_lock };
>
>int __attribute__((__section__(".sched.text"))) cond_resched_softirq(void)
>{
> do { if (__builtin_expect(!!(!(((current_thread_info()->preempt_count) & (((1UL << (8))-1) << (0 + 8))))), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "kernel/sched.c", 5219, (__func__)); panic("BUG!"); } while (0); } while(0);
>
> if (need_resched() && system_state == SYSTEM_RUNNING) {
>  local_bh_enable();
>  __cond_resched();
>  local_bh_disable();
>  return 1;
> }
> return 0;
>}
>extern typeof(cond_resched_softirq) cond_resched_softirq; static const char __kstrtab_cond_resched_softirq[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "cond_resched_softirq"; static const struct kernel_symbol __ksymtab_cond_resched_softirq __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&cond_resched_softirq, __kstrtab_cond_resched_softirq };
>
>
>
>
>
>
>
>void __attribute__((__section__(".sched.text"))) yield(void)
>{
> do { (current_thread_info()->task)->state = (0); __asm__ __volatile__("": : :"memory"); } while (0);
> sys_sched_yield();
>}
>extern typeof(yield) yield; static const char __kstrtab_yield[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "yield"; static const struct kernel_symbol __ksymtab_yield __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&yield, __kstrtab_yield };
># 5251 "kernel/sched.c"
>void __attribute__((__section__(".sched.text"))) io_schedule(void)
>{
> struct rq *rq = &per_cpu__runqueues;
>
> delayacct_blkio_start();
> atomic_inc(&rq->nr_iowait);
> schedule();
> atomic_dec(&rq->nr_iowait);
> delayacct_blkio_end();
>}
>extern typeof(io_schedule) io_schedule; static const char __kstrtab_io_schedule[] __attribute__((section("__ksymtab_strings"), aligned(1))) = "" "io_schedule"; static const struct kernel_symbol __ksymtab_io_schedule __attribute__((__used__)) __attribute__((section("__ksymtab" ""), unused)) = { (unsigned long)&io_schedule, __kstrtab_io_schedule };
>
>long __attribute__((__section__(".sched.text"))) io_schedule_timeout(long timeout)
>{
> struct rq *rq = &per_cpu__runqueues;
> long ret;
>
> delayacct_blkio_start();
> atomic_inc(&rq->nr_iowait);
> ret = schedule_timeout(timeout);
> atomic_dec(&rq->nr_iowait);
> delayacct_blkio_end();
> return ret;
>}
># 5283 "kernel/sched.c"
> long sys_sched_get_priority_max(int policy)
>{
> int ret = -22;
>
> switch (policy) {
> case 1:
> case 2:
>  ret = 100 -1;
>  break;
> case 0:
> case 3:
> case 5:
>  ret = 0;
>  break;
> }
> return ret;
>}
># 5308 "kernel/sched.c"
> long sys_sched_get_priority_min(int policy)
>{
> int ret = -22;
>
> switch (policy) {
> case 1:
> case 2:
>  ret = 1;
>  break;
> case 0:
> case 3:
> case 5:
>  ret = 0;
> }
> return ret;
>}
># 5333 "kernel/sched.c"
>
>long sys_sched_rr_get_interval(pid_t pid, struct timespec *interval)
>{
> struct task_struct *p;
> unsigned int time_slice;
> int retval;
> struct timespec t;
>
> if (pid < 0)
>  return -22;
>
> retval = -3;
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> p = find_process_by_pid(pid);
> if (!p)
>  goto out_unlock;
>
> retval = security_task_getscheduler(p);
> if (retval)
>  goto out_unlock;
>
>
>
>
>
> time_slice = 0;
> if (p->policy == 2) {
>  time_slice = (100 * 100 / 1000);
> } else if (p->policy != 1) {
>  struct sched_entity *se = &p->se;
>  unsigned long flags;
>  struct rq *rq;
>
>  rq = task_rq_lock(p, &flags);
>  if (rq->cfs.load.weight)
>   time_slice = ((unsigned long)(sched_slice(&rq->cfs, se)) / (1000000000L / 100));
>  task_rq_unlock(rq, &flags);
> }
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> jiffies_to_timespec(time_slice, &t);
> retval = copy_to_user(interval, &t, sizeof(t)) ? -14 : 0;
> return retval;
>
>out_unlock:
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> return retval;
>}
>
>static const char stat_nam[] = "RSDTtZX";
>
>void sched_show_task(struct task_struct *p)
>{
> unsigned long free = 0;
> unsigned state;
>
> state = p->state ? __ffs(p->state) + 1 : 0;
> printk("<6>" "%-13.13s %c", p->comm,
>  state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
>
>
>
>
>
>
> if (state == 0)
>  printk("" "  running task    ");
> else
>  printk("" " %016lx ", thread_saved_pc(p));
># 5410 "kernel/sched.c"
> printk("" "%5lu %5d %6d\n", free,
>  task_pid_nr(p), task_pid_nr(p->real_parent));
>
> show_stack(p, ((void *)0));
>}
>
>void show_state_filter(unsigned long state_filter)
>{
> struct task_struct *g, *p;
>
>
>
>
>
> printk("<6>"
>  "  task                        PC stack   pid father\n");
>
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
> for (g = p = &init_task ; (g = p = ({ const typeof( ((struct task_struct *)0)->tasks ) *__mptr = (({ typeof((g)->tasks.next) _________p1 = (*(volatile typeof((g)->tasks.next) *)&((g)->tasks.next)); do { } while (0); (_________p1); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,tasks) );})) != &init_task ; ) do {
>
>
>
>
>  touch_nmi_watchdog();
>  if (!state_filter || (p->state & state_filter))
>   sched_show_task(p);
> } while ((p = next_thread(p)) != g);
>
> touch_all_softlockup_watchdogs();
>
>
> sysrq_sched_debug_show();
>
> do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0);
>
>
>
> if (state_filter == -1)
>  debug_show_all_locks();
>}
>
>void __attribute__ ((__section__(".cpuinit.text"))) __attribute__((__cold__)) init_idle_bootup_task(struct task_struct *idle)
>{
> idle->sched_class = &idle_sched_class;
>}
># 5464 "kernel/sched.c"
>void __attribute__ ((__section__(".cpuinit.text"))) __attribute__((__cold__)) init_idle(struct task_struct *idle, int cpu)
>{
> struct rq *rq = (&(*((void)((cpu)), &per_cpu__runqueues)));
> unsigned long flags;
>
> __sched_fork(idle);
> idle->se.exec_start = sched_clock();
>
> idle->prio = idle->normal_prio = (100 + 40);
> idle->cpus_allowed = (*({ typeof(_unused_cpumask_arg_) m; if (sizeof(m) == sizeof(unsigned long)) { m.bits[0] = 1UL<<(cpu); } else { __cpus_clear(&(m), 1); __cpu_set(((cpu)), &(m)); } &m; }));
> __set_task_cpu(idle, cpu);
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
> rq->curr = rq->idle = idle;
>
>
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&rq->lock); } while (0); } while (0);
>
>
>
>
>
> ((struct thread_info *)(idle)->stack)->preempt_count = 0;
>
>
>
>
> idle->sched_class = &idle_sched_class;
>}
># 5502 "kernel/sched.c"
>cpumask_t nohz_cpu_mask = (cpumask_t) { { [0 ... (((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))-1] = 0UL } };
># 5513 "kernel/sched.c"
>static inline __attribute__((always_inline)) void sched_init_granularity(void)
>{
> unsigned int factor = 1 + ( __builtin_constant_p(1) ? ( (1) < 1 ? ____ilog2_NaN() : (1) & (1ULL << 63) ? 63 : (1) & (1ULL << 62) ? 62 : (1) & (1ULL << 61) ? 61 : (1) & (1ULL << 60) ? 60 : (1) & (1ULL << 59) ? 59 : (1) & (1ULL << 58) ? 58 : (1) & (1ULL << 57) ? 57 : (1) & (1ULL << 56) ? 56 : (1) & (1ULL << 55) ? 55 : (1) & (1ULL << 54) ? 54 : (1) & (1ULL << 53) ? 53 : (1) & (1ULL << 52) ? 52 : (1) & (1ULL << 51) ? 51 : (1) & (1ULL << 50) ? 50 : (1) & (1ULL << 49) ? 49 : (1) & (1ULL << 48) ? 48 : (1) & (1ULL << 47) ? 47 : (1) & (1ULL << 46) ? 46 : (1) & (1ULL << 45) ? 45 : (1) & (1ULL << 44) ? 44 : (1) & (1ULL << 43) ? 43 : (1) & (1ULL << 42) ? 42 : (1) & (1ULL << 41) ? 41 : (1) & (1ULL << 40) ? 40 : (1) & (1ULL << 39) ? 39 : (1) & (1ULL << 38) ? 38 : (1) & (1ULL << 37) ? 37 : (1) & (1ULL << 36) ? 36 : (1) & (1ULL << 35) ? 35 : (1) & (1ULL << 34) ? 34 : (1) & (1ULL << 33) ? 33 : (1) & (1ULL << 32) ? 32 : (1) & (1ULL << 31) ? 31 : (1) & (1ULL << 30) ? 30 : (1) & (1ULL << 29) ? 29 : (1) & (1ULL << 28) ? 28 : (1) & (1ULL << 27) ? 27 : (1) & (1ULL << 26) ? 26 : (1) & (1ULL << 25) ? 25 : (1) & (1ULL << 24) ? 24 : (1) & (1ULL << 23) ? 23 : (1) & (1ULL << 22) ? 22 : (1) & (1ULL << 21) ? 21 : (1) & (1ULL << 20) ? 20 : (1) & (1ULL << 19) ? 19 : (1) & (1ULL << 18) ? 18 : (1) & (1ULL << 17) ? 17 : (1) & (1ULL << 16) ? 16 : (1) & (1ULL << 15) ? 15 : (1) & (1ULL << 14) ? 14 : (1) & (1ULL << 13) ? 13 : (1) & (1ULL << 12) ? 12 : (1) & (1ULL << 11) ? 11 : (1) & (1ULL << 10) ? 10 : (1) & (1ULL << 9) ? 9 : (1) & (1ULL << 8) ? 8 : (1) & (1ULL << 7) ? 7 : (1) & (1ULL << 6) ? 6 : (1) & (1ULL << 5) ? 5 : (1) & (1ULL << 4) ? 4 : (1) & (1ULL << 3) ? 3 : (1) & (1ULL << 2) ? 2 : (1) & (1ULL << 1) ? 1 : (1) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof(1) <= 4) ? __ilog2_u32(1) : __ilog2_u64(1) );
> const unsigned long limit = 200000000;
>
> sysctl_sched_min_granularity *= factor;
> if (sysctl_sched_min_granularity > limit)
>  sysctl_sched_min_granularity = limit;
>
> sysctl_sched_latency *= factor;
> if (sysctl_sched_latency > limit)
>  sysctl_sched_latency = limit;
>
> sysctl_sched_wakeup_granularity *= factor;
>}
># 7515 "kernel/sched.c"
>void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) sched_init_smp(void)
>{
> sched_init_granularity();
>}
>
>
>int in_sched_functions(unsigned long addr)
>{
> return 0 ||
>  (addr >= (unsigned long)__sched_text_start
>  && addr < (unsigned long)__sched_text_end);
>}
>
>static void init_cfs_rq(struct cfs_rq *cfs_rq, struct rq *rq)
>{
> cfs_rq->tasks_timeline = (struct rb_root) { ((void *)0), };
> INIT_LIST_HEAD(&cfs_rq->tasks);
>
>
>
> cfs_rq->min_vruntime = (u64)(-(1LL << 20));
>}
>
>static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
>{
> struct rt_prio_array *array;
> int i;
>
> array = &rt_rq->active;
> for (i = 0; i < 100; i++) {
>  INIT_LIST_HEAD(array->queue + i);
>  __clear_bit(i, array->bitmap);
> }
>
> __set_bit(100, array->bitmap);
># 7559 "kernel/sched.c"
> rt_rq->rt_time = 0;
> rt_rq->rt_throttled = 0;
> rt_rq->rt_runtime = 0;
> do { *(&rt_rq->rt_runtime_lock) = (spinlock_t) { .raw_lock = { }, }; } while (0);
>
>
>
>
>
>}
># 7630 "kernel/sched.c"
>void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) sched_init(void)
>{
> int i, j;
> unsigned long alloc_size = 0, ptr;
># 7648 "kernel/sched.c"
> if (alloc_size) {
>  ptr = (unsigned long)__alloc_bootmem(alloc_size, (1 << 6), to_phys((void *) (unsigned long) ((uml_physmem))));
># 7681 "kernel/sched.c"
> }
>
>
>
>
>
> init_rt_bandwidth(&def_rt_bandwidth,
>   global_rt_period(), global_rt_runtime());
># 7710 "kernel/sched.c"
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_possible_map) {
>  struct rq *rq;
>
>  rq = (&(*((void)((i)), &per_cpu__runqueues)));
>  do { *(&rq->lock) = (spinlock_t) { .raw_lock = { }, }; } while (0);
>  do { (void)(&rq->rq_lock_key); } while (0);
>  rq->nr_running = 0;
>  init_cfs_rq(&rq->cfs, rq);
>  init_rt_rq(&rq->rt, rq);
># 7765 "kernel/sched.c"
>  rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
># 7779 "kernel/sched.c"
>  for (j = 0; j < 5; j++)
>   rq->cpu_load[j] = 0;
># 7792 "kernel/sched.c"
>  init_rq_hrtick(rq);
>  (((&rq->nr_iowait)->counter) = (0));
> }
>
> set_load_weight(&init_task);
># 7807 "kernel/sched.c"
> plist_head_init(&init_task.pi_waiters, &init_task.pi_lock);
>
>
>
>
>
> atomic_inc(&init_mm.mm_count);
> enter_lazy_tlb(&init_mm, (current_thread_info()->task));
>
>
>
>
>
>
>
> init_idle((current_thread_info()->task), 0);
>
>
>
> (current_thread_info()->task)->sched_class = &fair_sched_class;
>
> scheduler_running = 1;
>}
># 7857 "kernel/sched.c"
>static void normalize_task(struct rq *rq, struct task_struct *p)
>{
> int on_rq;
>
> update_rq_clock(rq);
> on_rq = p->se.on_rq;
> if (on_rq)
>  deactivate_task(rq, p, 0);
> __setscheduler(rq, p, 0, 0);
> if (on_rq) {
>  activate_task(rq, p, 0);
>  resched_task(rq->curr);
> }
>}
>
>void normalize_rt_tasks(void)
>{
> struct task_struct *g, *p;
> unsigned long flags;
> struct rq *rq;
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0); } while (0);
> for (g = p = &init_task ; (g = p = ({ const typeof( ((struct task_struct *)0)->tasks ) *__mptr = (({ typeof((g)->tasks.next) _________p1 = (*(volatile typeof((g)->tasks.next) *)&((g)->tasks.next)); do { } while (0); (_________p1); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,tasks) );})) != &init_task ; ) do {
>
>
>
>  if (!p->mm)
>   continue;
>
>  p->se.exec_start = 0;
>
>
>
>
>
>
>  if (!rt_task(p)) {
>
>
>
>
>   if ((((p)->static_prio) - 100 - 20) < 0 && p->mm)
>    set_user_nice(p, 0);
>   continue;
>  }
>
>  do { do { } while (0); (void)0; (void)(&p->pi_lock); } while (0);
>  rq = __task_rq_lock(p);
>
>  normalize_task(rq, p);
>
>  __task_rq_unlock(rq);
>  do { do { } while (0); (void)0; (void)(&p->pi_lock); } while (0);
> } while ((p = next_thread(p)) != g);
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&tasklist_lock); } while (0); } while (0);
>}
># 8028 "kernel/sched.c"
>static inline __attribute__((always_inline)) void free_fair_sched_group(struct task_group *tg)
>{
>}
>
>static inline __attribute__((always_inline))
>int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) void register_fair_sched_group(struct task_group *tg, int cpu)
>{
>}
>
>static inline __attribute__((always_inline)) void unregister_fair_sched_group(struct task_group *tg, int cpu)
>{
>}
># 8117 "kernel/sched.c"
>static inline __attribute__((always_inline)) void free_rt_sched_group(struct task_group *tg)
>{
>}
>
>static inline __attribute__((always_inline))
>int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
>{
> return 1;
>}
>
>static inline __attribute__((always_inline)) void register_rt_sched_group(struct task_group *tg, int cpu)
>{
>}
>
>static inline __attribute__((always_inline)) void unregister_rt_sched_group(struct task_group *tg, int cpu)
>{
>}
># 8496 "kernel/sched.c"
>static int sched_rt_global_constraints(void)
>{
> unsigned long flags;
> int i;
>
> do { do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); (flags) = get_signals(); } while(0); block_signals(); } while(0); do { do { } while (0); (void)0; (void)(&def_rt_bandwidth.rt_runtime_lock); } while (0); } while (0);
> for (((i)) = 0; ((i)) < 1; ((i))++, (void)cpu_possible_map) {
>  struct rt_rq *rt_rq = &(&(*((void)((i)), &per_cpu__runqueues)))->rt;
>
>  do { do { } while (0); (void)0; (void)(&rt_rq->rt_runtime_lock); } while (0);
>  rt_rq->rt_runtime = global_rt_runtime();
>  do { do { } while (0); (void)0; (void)(&rt_rq->rt_runtime_lock); } while (0);
> }
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); set_signals(flags); } while(0); do { do { } while (0); (void)0; (void)(&def_rt_bandwidth.rt_runtime_lock); } while (0); } while (0);
>
> return 0;
>}
>
>
>int sched_rt_handler(struct ctl_table *table, int write,
>  struct file *filp, void *buffer, size_t *lenp,
>  loff_t *ppos)
>{
> int ret;
> int old_period, old_runtime;
> static struct mutex mutex = { .count = { (1) } , .wait_lock = (spinlock_t) { .raw_lock = { }, } , .wait_list = { &(mutex.wait_list), &(mutex.wait_list) } };
>
> mutex_lock(&mutex);
> old_period = sysctl_sched_rt_period;
> old_runtime = sysctl_sched_rt_runtime;
>
> ret = proc_dointvec(table, write, filp, buffer, lenp, ppos);
>
> if (!ret && write) {
>  ret = sched_rt_global_constraints();
>  if (ret) {
>   sysctl_sched_rt_period = old_period;
>   sysctl_sched_rt_runtime = old_runtime;
>  } else {
>   def_rt_bandwidth.rt_runtime = global_rt_runtime();
>   def_rt_bandwidth.rt_period =
>    ns_to_ktime(global_rt_period());
>  }
> }
> mutex_unlock(&mutex);
>
> return ret;
>}

Actions: View

Attachments on bug 449265: 307304