add bfin ice

diff --git a/bfin-5761/reduce-ice b/bfin-5761/reduce-ice
new file mode 100755 (executable)
index 0000000..7e26aa0
--- /dev/null
+++ b/bfin-5761/reduce-ice
@@ -0,0 +1,13 @@
+#!/bin/bash
+#
+# Run like:
+#  multidelta -level=# ./reduce-ice $FILE
+#  levels: 0 0 1 1 2 2 10 10
+#
+
+FILE=super.i
+CC=/usr/local/src/blackfin/toolchains/20091208/bfin-uclinux/bin/bfin-uclinux-gcc
+CFLAGS="-fno-delete-null-pointer-checks -O2"
+STRING="multi-issue"
+
+$CC -pipe -c $CFLAGS $FILE 2>&1 | grep "$STRING"

diff --git a/bfin-5761/super.i b/bfin-5761/super.i
new file mode 100644 (file)
index 0000000..9788461
--- /dev/null
+++ b/bfin-5761/super.i
@@ -0,0 +1,16 @@
+typedef unsigned long long u64;
+struct super_block {
+       unsigned s_blocksize;
+       void *s_bdev;
+};
+sb_bread(struct super_block *sb, u64 block)
+{
+       __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+fill(struct super_block *sb)
+{
+       u64 *bh;
+       unsigned nr;
+       nr = *bh >> 1;
+       sb_bread(sb, nr);
+}

diff --git a/bfin-5761/super.i.0 b/bfin-5761/super.i.0
new file mode 100644 (file)
index 0000000..777ee91
--- /dev/null
+++ b/bfin-5761/super.i.0
@@ -0,0 +1,20040 @@
+# 1 "fs/sysv/super.c"
+# 1 "/usr/local/src/blackfin/git/linux-kernel//"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "./include/linux/autoconf.h" 1
+# 1 "<command-line>" 2
+# 1 "fs/sysv/super.c"
+# 23 "fs/sysv/super.c"
+# 1 "include/linux/module.h" 1
+# 9 "include/linux/module.h"
+# 1 "include/linux/list.h" 1
+
+
+
+# 1 "include/linux/stddef.h" 1
+
+
+
+# 1 "include/linux/compiler.h" 1
+# 40 "include/linux/compiler.h"
+# 1 "include/linux/compiler-gcc.h" 1
+# 86 "include/linux/compiler-gcc.h"
+# 1 "include/linux/compiler-gcc4.h" 1
+# 86 "include/linux/compiler-gcc.h" 2
+# 41 "include/linux/compiler.h" 2
+# 58 "include/linux/compiler.h"
+struct ftrace_branch_data {
+ const char *func;
+ const char *file;
+ unsigned line;
+ union {
+  struct {
+   unsigned long correct;
+   unsigned long incorrect;
+  };
+  struct {
+   unsigned long miss;
+   unsigned long hit;
+  };
+  unsigned long miss_hit[2];
+ };
+};
+# 5 "include/linux/stddef.h" 2
+# 15 "include/linux/stddef.h"
+enum {
+ false = 0,
+ true = 1
+};
+# 5 "include/linux/list.h" 2
+# 1 "include/linux/poison.h" 1
+# 6 "include/linux/list.h" 2
+# 1 "include/linux/prefetch.h" 1
+# 13 "include/linux/prefetch.h"
+# 1 "include/linux/types.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 1 "include/asm-generic/types.h" 1
+
+
+
+
+
+
+# 1 "include/asm-generic/int-ll64.h" 1
+# 11 "include/asm-generic/int-ll64.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitsperlong.h" 1
+# 1 "include/asm-generic/bitsperlong.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitsperlong.h" 2
+# 12 "include/asm-generic/int-ll64.h" 2
+
+
+
+
+
+
+
+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;
+# 42 "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;
+# 8 "include/asm-generic/types.h" 2
+
+
+
+typedef unsigned short umode_t;
+# 34 "include/asm-generic/types.h"
+typedef u32 dma_addr_t;
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 2
+# 5 "include/linux/types.h" 2
+# 14 "include/linux/types.h"
+# 1 "include/linux/posix_types.h" 1
+# 36 "include/linux/posix_types.h"
+typedef struct {
+ unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
+} __kernel_fd_set;
+
+
+typedef void (*__kernel_sighandler_t)(int);
+
+
+typedef int __kernel_key_t;
+typedef int __kernel_mqd_t;
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/posix_types.h" 1
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/posix_types.h"
+typedef unsigned short __kernel_mode_t;
+
+
+typedef unsigned short __kernel_nlink_t;
+
+
+typedef unsigned int __kernel_ipc_pid_t;
+
+
+typedef unsigned long __kernel_size_t;
+typedef long __kernel_ssize_t;
+typedef int __kernel_ptrdiff_t;
+
+
+typedef unsigned short __kernel_old_uid_t;
+typedef unsigned short __kernel_old_gid_t;
+
+
+typedef unsigned short __kernel_old_dev_t;
+
+
+# 1 "include/asm-generic/posix_types.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitsperlong.h" 1
+# 5 "include/asm-generic/posix_types.h" 2
+# 14 "include/asm-generic/posix_types.h"
+typedef unsigned long __kernel_ino_t;
+# 26 "include/asm-generic/posix_types.h"
+typedef int __kernel_pid_t;
+
+
+
+
+
+
+
+typedef unsigned int __kernel_uid_t;
+typedef unsigned int __kernel_gid_t;
+
+
+
+typedef long __kernel_suseconds_t;
+
+
+
+typedef int __kernel_daddr_t;
+
+
+
+typedef __kernel_uid_t __kernel_uid32_t;
+typedef __kernel_gid_t __kernel_gid32_t;
+# 79 "include/asm-generic/posix_types.h"
+typedef long __kernel_off_t;
+typedef long long __kernel_loff_t;
+typedef long __kernel_time_t;
+typedef long __kernel_clock_t;
+typedef int __kernel_timer_t;
+typedef int __kernel_clockid_t;
+typedef char * __kernel_caddr_t;
+typedef unsigned short __kernel_uid16_t;
+typedef unsigned short __kernel_gid16_t;
+
+typedef struct {
+ int val[2];
+} __kernel_fsid_t;
+
+
+
+
+static inline __attribute__((always_inline)) void __FD_SET(unsigned long __fd, __kernel_fd_set *__fdsetp)
+{
+ unsigned long __tmp = __fd / (8 * sizeof(unsigned long));
+ unsigned long __rem = __fd % (8 * sizeof(unsigned long));
+ __fdsetp->fds_bits[__tmp] |= (1UL<<__rem);
+}
+
+
+static inline __attribute__((always_inline)) void __FD_CLR(unsigned long __fd, __kernel_fd_set *__fdsetp)
+{
+ unsigned long __tmp = __fd / (8 * sizeof(unsigned long));
+ unsigned long __rem = __fd % (8 * sizeof(unsigned long));
+ __fdsetp->fds_bits[__tmp] &= ~(1UL<<__rem);
+}
+
+
+static inline __attribute__((always_inline)) int __FD_ISSET(unsigned long __fd, 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 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++;
+ }
+}
+# 32 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/posix_types.h" 2
+# 48 "include/linux/posix_types.h" 2
+# 15 "include/linux/types.h" 2
+
+
+
+typedef __u32 __kernel_dev_t;
+
+typedef __kernel_fd_set fd_set;
+typedef __kernel_dev_t dev_t;
+typedef __kernel_ino_t ino_t;
+typedef __kernel_mode_t mode_t;
+typedef __kernel_nlink_t nlink_t;
+typedef __kernel_off_t off_t;
+typedef __kernel_pid_t pid_t;
+typedef __kernel_daddr_t daddr_t;
+typedef __kernel_key_t key_t;
+typedef __kernel_suseconds_t suseconds_t;
+typedef __kernel_timer_t timer_t;
+typedef __kernel_clockid_t clockid_t;
+typedef __kernel_mqd_t mqd_t;
+
+typedef _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;
+
+
+
+typedef __kernel_loff_t loff_t;
+# 59 "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;
+# 135 "include/linux/types.h"
+typedef u64 sector_t;
+typedef u64 blkcnt_t;
+# 168 "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 unsigned fmode_t;
+
+
+
+
+typedef u32 phys_addr_t;
+
+
+typedef phys_addr_t resource_size_t;
+
+typedef struct {
+ volatile int counter;
+} atomic_t;
+
+
+
+
+
+
+
+struct ustat {
+ __kernel_daddr_t f_tfree;
+ __kernel_ino_t f_tinode;
+ char f_fname[6];
+ char f_fpack[6];
+};
+# 14 "include/linux/prefetch.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h" 1
+# 16 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ptrace.h" 1
+# 30 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ptrace.h"
+struct pt_regs {
+ long orig_pc;
+ long ipend;
+ long seqstat;
+ long rete;
+ long retn;
+ long retx;
+ long pc;
+ long rets;
+ long reserved;
+ long astat;
+ long lb1;
+ long lb0;
+ long lt1;
+ long lt0;
+ long lc1;
+ long lc0;
+ long a1w;
+ long a1x;
+ long a0w;
+ long a0x;
+ long b3;
+ long b2;
+ long b1;
+ long b0;
+ long l3;
+ long l2;
+ long l1;
+ long l0;
+ long m3;
+ long m2;
+ long m1;
+ long m0;
+ long i3;
+ long i2;
+ long i1;
+ long i0;
+ long usp;
+ long fp;
+ long p5;
+ long p4;
+ long p3;
+ long p2;
+ long p1;
+ long p0;
+ long r7;
+ long r6;
+ long r5;
+ long r4;
+ long r3;
+ long r2;
+ long r1;
+ long r0;
+ long orig_r0;
+ long orig_p0;
+ long syscfg;
+};
+# 105 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ptrace.h"
+extern void show_regs(struct pt_regs *);
+# 17 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/blackfin.h" 1
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/blackfin.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/bf533.h" 1
+# 13 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/blackfin.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/defBF532.h" 1
+# 13 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/defBF532.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/def_LPBlackfin.h" 1
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/def_LPBlackfin.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/anomaly.h" 1
+# 13 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/def_LPBlackfin.h" 2
+# 14 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/defBF532.h" 2
+# 14 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/blackfin.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/anomaly.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/blackfin.h" 2
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/cdefBF532.h" 1
+# 14 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/cdefBF532.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_LPBlackfin.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/cdefBF532.h" 2
+# 18 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/blackfin.h" 2
+# 18 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h" 2
+
+static inline __attribute__((always_inline)) unsigned long rdusp(void)
+{
+ unsigned long usp;
+
+ __asm__ __volatile__("%0 = usp;\n\t":"=da"(usp));
+ return usp;
+}
+
+static inline __attribute__((always_inline)) void wrusp(unsigned long usp)
+{
+ __asm__ __volatile__("usp = %0;\n\t"::"da"(usp));
+}
+
+static inline __attribute__((always_inline)) unsigned long __get_SP(void)
+{
+ unsigned long sp;
+
+ __asm__ __volatile__("%0 = sp;\n\t" : "=da"(sp));
+ return sp;
+}
+# 53 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h"
+struct thread_struct {
+ unsigned long ksp;
+ unsigned long usp;
+ unsigned short seqstat;
+ unsigned long esp0;
+ unsigned long pc;
+ void * debuggerinfo;
+};
+
+
+
+
+
+
+extern void start_thread(struct pt_regs *regs, unsigned long new_ip,
+            unsigned long new_sp);
+
+
+struct task_struct;
+
+
+static inline __attribute__((always_inline)) void release_thread(struct task_struct *dead_task)
+{
+}
+
+
+
+extern int kernel_thread(int (*fn) (void *), void *arg, unsigned long flags);
+
+
+
+
+static inline __attribute__((always_inline)) void exit_thread(void)
+{
+}
+
+
+
+
+
+
+unsigned long get_wchan(struct task_struct *p);
+# 109 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h"
+static inline __attribute__((always_inline)) uint32_t __attribute__((pure)) bfin_revid(void)
+{
+
+ uint32_t revid = (({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }) & 0xF0000000) >> 28;
+# 124 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h"
+ return revid;
+}
+
+static inline __attribute__((always_inline)) uint16_t __attribute__((pure)) bfin_cpuid(void)
+{
+ return (({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }) & 0x0FFFF000) >> 12;
+}
+
+static inline __attribute__((always_inline)) uint32_t __attribute__((pure)) bfin_dspid(void)
+{
+ return ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFE05000) ); __v; });
+}
+
+
+
+static inline __attribute__((always_inline)) uint32_t __attribute__((pure)) bfin_compiled_revid(void)
+{
+# 150 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h"
+ return 4;
+# 160 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/processor.h"
+}
+# 15 "include/linux/prefetch.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cache.h" 1
+# 9 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cache.h"
+# 1 "include/linux/linkage.h" 1
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/linkage.h" 1
+# 6 "include/linux/linkage.h" 2
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cache.h" 2
+# 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
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 1
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h"
+# 1 "include/linux/irqflags.h" 1
+# 14 "include/linux/irqflags.h"
+# 1 "include/linux/typecheck.h" 1
+# 15 "include/linux/irqflags.h" 2
+# 57 "include/linux/irqflags.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irqflags.h" 1
+# 16 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irqflags.h"
+extern unsigned long bfin_irq_flags;
+
+
+static inline __attribute__((always_inline)) void bfin_sti(unsigned long flags)
+{
+ asm volatile("sti %0;" : : "d" (flags));
+}
+
+static inline __attribute__((always_inline)) unsigned long bfin_cli(void)
+{
+ unsigned long flags;
+ asm volatile("cli %0;" : "=d" (flags));
+ return flags;
+}
+# 176 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irqflags.h"
+static inline __attribute__((always_inline)) void raw_local_irq_disable(void)
+{
+ bfin_cli();
+}
+static inline __attribute__((always_inline)) void raw_local_irq_enable(void)
+{
+ bfin_sti(bfin_irq_flags);
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) unsigned long __raw_local_irq_save(void)
+{
+ unsigned long flags = bfin_cli();
+
+
+
+ return flags;
+}
+# 207 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irqflags.h"
+static inline __attribute__((always_inline)) void raw_local_irq_restore(unsigned long flags)
+{
+ if (!(((flags) & ~0x3f) == 0))
+  raw_local_irq_enable();
+}
+# 58 "include/linux/irqflags.h" 2
+# 13 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 2
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pda.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pda.h"
+struct blackfin_pda {
+ struct blackfin_pda *next;
+
+ unsigned long syscfg;
+
+
+
+
+ unsigned long *ipdt;
+ unsigned long *ipdt_swapcount;
+ unsigned long *dpdt;
+ unsigned long *dpdt_swapcount;
+
+
+
+
+
+
+
+ unsigned long ex_iptr;
+ unsigned long ex_optr;
+ unsigned long ex_buf[4];
+ unsigned long ex_imask;
+ unsigned long ex_ipend;
+ unsigned long *ex_stack;
+
+
+ unsigned long last_cplb_fault_retx;
+
+ unsigned long dcplb_fault_addr;
+ unsigned long icplb_fault_addr;
+ unsigned long retx;
+ unsigned long seqstat;
+ unsigned int __nmi_count;
+
+ unsigned long dcplb_doublefault_addr;
+ unsigned long icplb_doublefault_addr;
+ unsigned long retx_doublefault;
+ unsigned long seqstat_doublefault;
+
+};
+
+extern struct blackfin_pda cpu_pda[];
+# 16 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq.h" 1
+# 18 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/irq.h" 1
+# 19 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq.h" 2
+# 36 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq.h"
+# 1 "include/asm-generic/irq.h" 1
+# 13 "include/asm-generic/irq.h"
+static inline __attribute__((always_inline)) int irq_canonicalize(int irq)
+{
+ return irq;
+}
+# 37 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq.h" 2
+# 17 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 2
+# 107 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h"
+struct __xchg_dummy {
+ unsigned long a[100];
+};
+
+
+
+
+static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void *ptr,
+       int size)
+{
+ unsigned long tmp = 0;
+ unsigned long flags;
+
+ do { (flags) = __raw_local_irq_save(); } while (0);
+
+ switch (size) {
+ case 1:
+  __asm__ __volatile__
+   ("%0 = b%2 (z);\n\t"
+    "b%2 = %1;\n\t"
+    : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
+  break;
+ case 2:
+  __asm__ __volatile__
+   ("%0 = w%2 (z);\n\t"
+    "w%2 = %1;\n\t"
+    : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
+  break;
+ case 4:
+  __asm__ __volatile__
+   ("%0 = %2;\n\t"
+    "%2 = %1;\n\t"
+    : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
+  break;
+ }
+ raw_local_irq_restore(flags);
+ return tmp;
+}
+
+# 1 "include/asm-generic/cmpxchg-local.h" 1
+
+
+
+
+
+extern unsigned long wrong_size_cmpxchg(volatile void *ptr);
+
+
+
+
+
+static inline __attribute__((always_inline)) unsigned long __cmpxchg_local_generic(volatile void *ptr,
+  unsigned long old, unsigned long new, int size)
+{
+ unsigned long flags, prev;
+
+
+
+
+ if (size == 8 && sizeof(unsigned long) != 8)
+  wrong_size_cmpxchg(ptr);
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ switch (size) {
+ case 1: prev = *(u8 *)ptr;
+  if (prev == old)
+   *(u8 *)ptr = (u8)new;
+  break;
+ case 2: prev = *(u16 *)ptr;
+  if (prev == old)
+   *(u16 *)ptr = (u16)new;
+  break;
+ case 4: prev = *(u32 *)ptr;
+  if (prev == old)
+   *(u32 *)ptr = (u32)new;
+  break;
+ case 8: prev = *(u64 *)ptr;
+  if (prev == old)
+   *(u64 *)ptr = (u64)new;
+  break;
+ default:
+  wrong_size_cmpxchg(ptr);
+ }
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+ return prev;
+}
+
+
+
+
+static inline __attribute__((always_inline)) u64 __cmpxchg64_local_generic(volatile void *ptr,
+  u64 old, u64 new)
+{
+ u64 prev;
+ unsigned long flags;
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ prev = *(u64 *)ptr;
+ if (prev == old)
+  *(u64 *)ptr = new;
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+ return prev;
+}
+# 147 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 2
+# 157 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h"
+# 1 "include/asm-generic/cmpxchg.h" 1
+# 158 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 2
+# 171 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/l1layout.h" 1
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/l1layout.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/blackfin.h" 1
+# 17 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/blackfin.h"
+static inline __attribute__((always_inline)) void SSYNC(void)
+{
+ int _tmp;
+ if ((0x0004 < 6))
+  __asm__ __volatile__(
+   "cli %0;"
+   "nop;"
+   "nop;"
+   "ssync;"
+   "sti %0;"
+   : "=d" (_tmp)
+  );
+ else if ((0x0004 < 5))
+  __asm__ __volatile__(
+   "nop;"
+   "nop;"
+   "nop;"
+   "ssync;"
+  );
+ else
+  __asm__ __volatile__("ssync;");
+}
+
+
+static inline __attribute__((always_inline)) void CSYNC(void)
+{
+ int _tmp;
+ if ((0x0004 < 6))
+  __asm__ __volatile__(
+   "cli %0;"
+   "nop;"
+   "nop;"
+   "csync;"
+   "sti %0;"
+   : "=d" (_tmp)
+  );
+ else if ((0x0004 < 5))
+  __asm__ __volatile__(
+   "nop;"
+   "nop;"
+   "nop;"
+   "csync;"
+  );
+ else
+  __asm__ __volatile__("csync;");
+}
+# 92 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/blackfin.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/mem_map.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/mem_map.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/mach-bf533/include/mach/mem_map.h" 1
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/mem_map.h" 2
+# 53 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/mem_map.h"
+static inline __attribute__((always_inline)) unsigned long get_l1_scratch_start_cpu(int cpu)
+{
+ return 0xFFB00000;
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_code_start_cpu(int cpu)
+{
+ return 0xFFA00000;
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_data_a_start_cpu(int cpu)
+{
+ return 0xFF800000;
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_data_b_start_cpu(int cpu)
+{
+ return 0xFF900000;
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_scratch_start(void)
+{
+ return get_l1_scratch_start_cpu(0);
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_code_start(void)
+{
+ return get_l1_code_start_cpu(0);
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_data_a_start(void)
+{
+ return get_l1_data_a_start_cpu(0);
+}
+static inline __attribute__((always_inline)) unsigned long get_l1_data_b_start(void)
+{
+ return get_l1_data_b_start_cpu(0);
+}
+# 93 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/blackfin.h" 2
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bfin-global.h" 1
+# 33 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bfin-global.h"
+extern void bfin_setup_caches(unsigned int cpu);
+extern void bfin_setup_cpudata(unsigned int cpu);
+
+extern unsigned long get_cclk(void);
+extern unsigned long get_sclk(void);
+extern unsigned long sclk_to_usecs(unsigned long sclk);
+extern unsigned long usecs_to_sclk(unsigned long usecs);
+
+struct pt_regs;
+extern void dump_bfin_process(struct pt_regs *regs);
+extern void dump_bfin_mem(struct pt_regs *regs);
+extern void dump_bfin_trace_buffer(void);
+
+
+extern int init_arch_irq(void);
+extern void init_exception_vectors(void);
+extern void program_IAR(void);
+
+extern void lower_to_irq14(void);
+extern void bfin_return_from_exception(void);
+extern void asm_do_IRQ(unsigned int irq, struct pt_regs *regs);
+extern int bfin_internal_set_wake(unsigned int irq, unsigned int state);
+
+extern void *l1_data_A_sram_alloc(size_t);
+extern void *l1_data_B_sram_alloc(size_t);
+extern void *l1_inst_sram_alloc(size_t);
+extern void *l1_data_sram_alloc(size_t);
+extern void *l1_data_sram_zalloc(size_t);
+extern void *l2_sram_alloc(size_t);
+extern void *l2_sram_zalloc(size_t);
+extern int l1_data_A_sram_free(const void*);
+extern int l1_data_B_sram_free(const void*);
+extern int l1_inst_sram_free(const void*);
+extern int l1_data_sram_free(const void*);
+extern int l2_sram_free(const void *);
+extern int sram_free(const void*);
+
+
+
+
+
+
+extern void *sram_alloc_with_lsl(size_t, unsigned long);
+extern int sram_free_with_lsl(const void*);
+
+extern void *isram_memcpy(void *dest, const void *src, size_t n);
+
+extern const char bfin_board_name[];
+
+extern unsigned long bfin_sic_iwr[];
+extern unsigned vr_wakeup;
+extern u16 _bfin_swrst;
+# 95 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/blackfin.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h" 1
+# 37 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+static __inline__ __attribute__((always_inline)) void bfin_write_PLL_CTL(unsigned int val)
+{
+ unsigned long flags = 0;
+# 49 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+ unsigned long iwr;
+
+
+ if (val == ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = w[%1] (z);" : "=d" (__v) : "a" (0xFFC00000) ); __v; }))
+  return;
+
+ do { (flags) = __raw_local_irq_save(); } while (0);
+# 70 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+ iwr = ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00124) ); __v; });
+
+
+ __asm__ __volatile__( "nop;" "w[%0] = %1;" : : "a" (0xFFC00000), "d" ((uint16_t)(val)) : "memory" );
+ SSYNC();
+ asm("IDLE;");
+# 86 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+ __asm__ __volatile__( "nop;" "[%0] = %1;" : : "a" (0xFFC00124), "d" (iwr) : "memory" );
+
+ raw_local_irq_restore(flags);
+}
+
+
+static __inline__ __attribute__((always_inline)) void bfin_write_VR_CTL(unsigned int val)
+{
+ unsigned long flags = 0;
+# 104 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+ unsigned long iwr;
+
+
+ if (val == ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = w[%1] (z);" : "=d" (__v) : "a" (0xFFC00008) ); __v; }))
+  return;
+
+ do { (flags) = __raw_local_irq_save(); } while (0);
+# 125 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+ iwr = ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00124) ); __v; });
+ __asm__ __volatile__( "nop;" "[%0] = %1;" : : "a" (0xFFC00124), "d" ((1 << (0))) : "memory" );
+
+
+ __asm__ __volatile__( "nop;" "w[%0] = %1;" : : "a" (0xFFC00008), "d" ((uint16_t)(val)) : "memory" );
+ SSYNC();
+ asm("IDLE;");
+# 142 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+ __asm__ __volatile__( "nop;" "[%0] = %1;" : : "a" (0xFFC00124), "d" (iwr) : "memory" );
+
+ raw_local_irq_restore(flags);
+}
+# 160 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+static inline __attribute__((always_inline)) void bfin_write_FIO_FLAG_D(unsigned short val) { unsigned long flags; do { (flags) = __raw_local_irq_save(); } while (0); __asm__ __volatile__( "nop;" "w[%0] = %1;" : : "a" (0xFFC00700), "d" ((uint16_t)(val)) : "memory" ); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); }
+static inline __attribute__((always_inline)) void bfin_write_FIO_FLAG_C(unsigned short val) { unsigned long flags; do { (flags) = __raw_local_irq_save(); } while (0); __asm__ __volatile__( "nop;" "w[%0] = %1;" : : "a" (0xFFC00704), "d" ((uint16_t)(val)) : "memory" ); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); }
+static inline __attribute__((always_inline)) void bfin_write_FIO_FLAG_S(unsigned short val) { unsigned long flags; do { (flags) = __raw_local_irq_save(); } while (0); __asm__ __volatile__( "nop;" "w[%0] = %1;" : : "a" (0xFFC00708), "d" ((uint16_t)(val)) : "memory" ); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); }
+static inline __attribute__((always_inline)) void bfin_write_FIO_FLAG_T(unsigned short val) { unsigned long flags; do { (flags) = __raw_local_irq_save(); } while (0); __asm__ __volatile__( "nop;" "w[%0] = %1;" : : "a" (0xFFC0070C), "d" ((uint16_t)(val)) : "memory" ); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); }
+# 176 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cdef_misc.h"
+static inline __attribute__((always_inline)) u16 bfin_read_FIO_FLAG_D(void) { unsigned long flags; u16 ret; do { (flags) = __raw_local_irq_save(); } while (0); ret = ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = w[%1] (z);" : "=d" (__v) : "a" (0xFFC00700) ); __v; }); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); return ret; }
+static inline __attribute__((always_inline)) u16 bfin_read_FIO_FLAG_C(void) { unsigned long flags; u16 ret; do { (flags) = __raw_local_irq_save(); } while (0); ret = ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = w[%1] (z);" : "=d" (__v) : "a" (0xFFC00704) ); __v; }); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); return ret; }
+static inline __attribute__((always_inline)) u16 bfin_read_FIO_FLAG_S(void) { unsigned long flags; u16 ret; do { (flags) = __raw_local_irq_save(); } while (0); ret = ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = w[%1] (z);" : "=d" (__v) : "a" (0xFFC00708) ); __v; }); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); return ret; }
+static inline __attribute__((always_inline)) u16 bfin_read_FIO_FLAG_T(void) { unsigned long flags; u16 ret; do { (flags) = __raw_local_irq_save(); } while (0); ret = ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = w[%1] (z);" : "=d" (__v) : "a" (0xFFC0070C) ); __v; }); ({ uint32_t __v; __asm__ __volatile__( "nop;" "%0 = [%1];" : "=d" (__v) : "a" (0xFFC00014) ); __v; }); raw_local_irq_restore(flags); return ret; }
+# 96 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/blackfin.h" 2
+# 13 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/l1layout.h" 2
+
+
+
+
+
+
+
+struct l1_scratch_task_info
+{
+
+ void *stack_start;
+
+
+
+ void *lowest_sp;
+};
+# 172 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/system.h" 2
+
+
+ struct task_struct *resume(struct task_struct *prev, struct task_struct *next);
+# 8 "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;
+}
+# 64 "include/linux/list.h"
+static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
+{
+ __list_add(new, head, head->next);
+}
+# 78 "include/linux/list.h"
+static inline __attribute__((always_inline)) void list_add_tail(struct list_head *new, struct list_head *head)
+{
+ __list_add(new, head->prev, head);
+}
+# 90 "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;
+}
+# 103 "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);
+}
+# 120 "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);
+}
+
+
+
+
+
+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;
+}
+# 202 "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_cut_position(struct list_head *list,
+  struct list_head *head, struct list_head *entry)
+{
+ struct list_head *new_first = entry->next;
+ list->next = head->next;
+ list->next->prev = list;
+ list->prev = entry;
+ entry->next = list;
+ head->next = new_first;
+ new_first->prev = head;
+}
+# 243 "include/linux/list.h"
+static inline __attribute__((always_inline)) void list_cut_position(struct list_head *list,
+  struct list_head *head, struct list_head *entry)
+{
+ if (list_empty(head))
+  return;
+ if (list_is_singular(head) &&
+  (head->next != entry && head != entry))
+  return;
+ if (entry == head)
+  INIT_LIST_HEAD(list);
+ else
+  __list_cut_position(list, head, entry);
+}
+
+static inline __attribute__((always_inline)) void __list_splice(const struct list_head *list,
+     struct list_head *prev,
+     struct list_head *next)
+{
+ struct list_head *first = list->next;
+ struct list_head *last = list->prev;
+
+ first->prev = prev;
+ prev->next = first;
+
+ last->next = next;
+ next->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, head->next);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void list_splice_tail(struct list_head *list,
+    struct list_head *head)
+{
+ if (!list_empty(list))
+  __list_splice(list, head->prev, head);
+}
+# 302 "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, head->next);
+  INIT_LIST_HEAD(list);
+ }
+}
+# 319 "include/linux/list.h"
+static inline __attribute__((always_inline)) void list_splice_tail_init(struct list_head *list,
+      struct list_head *head)
+{
+ if (!list_empty(list)) {
+  __list_splice(list, head->prev, head);
+  INIT_LIST_HEAD(list);
+ }
+}
+# 540 "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);
+}
+
+static inline __attribute__((always_inline)) void hlist_del_init(struct hlist_node *n)
+{
+ if (!hlist_unhashed(n)) {
+  __hlist_del(n);
+  INIT_HLIST_NODE(n);
+ }
+}
+
+static inline __attribute__((always_inline)) void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+{
+ struct hlist_node *first = h->first;
+ n->next = first;
+ if (first)
+  first->pprev = &n->next;
+ h->first = n;
+ n->pprev = &h->first;
+}
+
+
+static inline __attribute__((always_inline)) void hlist_add_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;
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) void hlist_move_list(struct hlist_head *old,
+       struct hlist_head *new)
+{
+ new->first = old->first;
+ if (new->first)
+  new->first->pprev = &new->first;
+ old->first = ((void *)0);
+}
+# 10 "include/linux/module.h" 2
+# 1 "include/linux/stat.h" 1
+
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/stat.h" 1
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/stat.h"
+struct stat {
+ unsigned short st_dev;
+ unsigned short __pad1;
+ unsigned long st_ino;
+ unsigned short st_mode;
+ unsigned short st_nlink;
+ unsigned short st_uid;
+ unsigned short st_gid;
+ unsigned short st_rdev;
+ unsigned short __pad2;
+ unsigned long st_size;
+ unsigned long st_blksize;
+ unsigned long st_blocks;
+ unsigned long st_atime;
+ unsigned long __unused1;
+ unsigned long st_mtime;
+ unsigned long __unused2;
+ unsigned long st_ctime;
+ unsigned long __unused3;
+ unsigned long __unused4;
+ unsigned long __unused5;
+};
+
+
+
+
+struct stat64 {
+ unsigned long long st_dev;
+ unsigned char __pad1[4];
+
+
+ unsigned long __st_ino;
+
+ unsigned int st_mode;
+ unsigned int st_nlink;
+
+ unsigned long st_uid;
+ unsigned long st_gid;
+
+ unsigned long long st_rdev;
+ unsigned char __pad2[4];
+
+ long long st_size;
+ unsigned long st_blksize;
+
+ long long st_blocks;
+
+ unsigned long st_atime;
+ unsigned long st_atime_nsec;
+
+ unsigned long st_mtime;
+ unsigned long st_mtime_nsec;
+
+ unsigned long st_ctime;
+ unsigned long st_ctime_nsec;
+
+ unsigned long long st_ino;
+};
+# 7 "include/linux/stat.h" 2
+# 60 "include/linux/stat.h"
+# 1 "include/linux/time.h" 1
+
+
+
+
+
+
+# 1 "include/linux/cache.h" 1
+
+
+
+# 1 "include/linux/kernel.h" 1
+# 10 "include/linux/kernel.h"
+# 1 "/usr/local/src/blackfin/toolchains/20091208/bfin-uclinux/lib/gcc/bfin-uclinux/4.3.4/include/stdarg.h" 1 3 4
+# 43 "/usr/local/src/blackfin/toolchains/20091208/bfin-uclinux/lib/gcc/bfin-uclinux/4.3.4/include/stdarg.h" 3 4
+typedef __builtin_va_list __gnuc_va_list;
+# 105 "/usr/local/src/blackfin/toolchains/20091208/bfin-uclinux/lib/gcc/bfin-uclinux/4.3.4/include/stdarg.h" 3 4
+typedef __gnuc_va_list va_list;
+# 11 "include/linux/kernel.h" 2
+
+
+
+
+# 1 "include/linux/bitops.h" 1
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 4 "include/linux/bitops.h" 2
+# 17 "include/linux/bitops.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitops.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitops.h"
+# 1 "include/asm-generic/bitops.h" 1
+# 23 "include/asm-generic/bitops.h"
+# 1 "include/asm-generic/bitops/__ffs.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/__ffs.h" 2
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long __ffs(unsigned long word)
+{
+ int num = 0;
+
+
+
+
+
+
+
+ if ((word & 0xffff) == 0) {
+  num += 16;
+  word >>= 16;
+ }
+ if ((word & 0xff) == 0) {
+  num += 8;
+  word >>= 8;
+ }
+ if ((word & 0xf) == 0) {
+  num += 4;
+  word >>= 4;
+ }
+ if ((word & 0x3) == 0) {
+  num += 2;
+  word >>= 2;
+ }
+ if ((word & 0x1) == 0)
+  num += 1;
+ return num;
+}
+# 24 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/ffz.h" 1
+# 25 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/fls.h" 1
+# 12 "include/asm-generic/bitops/fls.h"
+static inline __attribute__((always_inline)) __attribute__((always_inline)) int fls(int x)
+{
+ int r = 32;
+
+ if (!x)
+  return 0;
+ if (!(x & 0xffff0000u)) {
+  x <<= 16;
+  r -= 16;
+ }
+ if (!(x & 0xff000000u)) {
+  x <<= 8;
+  r -= 8;
+ }
+ if (!(x & 0xf0000000u)) {
+  x <<= 4;
+  r -= 4;
+ }
+ if (!(x & 0xc0000000u)) {
+  x <<= 2;
+  r -= 2;
+ }
+ if (!(x & 0x80000000u)) {
+  x <<= 1;
+  r -= 1;
+ }
+ return r;
+}
+# 26 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/__fls.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/__fls.h" 2
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long __fls(unsigned long word)
+{
+ int num = 32 - 1;
+
+
+
+
+
+
+
+ if (!(word & (~0ul << (32 -16)))) {
+  num -= 16;
+  word <<= 16;
+ }
+ if (!(word & (~0ul << (32 -8)))) {
+  num -= 8;
+  word <<= 8;
+ }
+ if (!(word & (~0ul << (32 -4)))) {
+  num -= 4;
+  word <<= 4;
+ }
+ if (!(word & (~0ul << (32 -2)))) {
+  num -= 2;
+  word <<= 2;
+ }
+ if (!(word & (~0ul << (32 -1))))
+  num -= 1;
+ return num;
+}
+# 27 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/fls64.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/fls64.h" 2
+# 18 "include/asm-generic/bitops/fls64.h"
+static inline __attribute__((always_inline)) __attribute__((always_inline)) int fls64(__u64 x)
+{
+ __u32 h = x >> 32;
+ if (h)
+  return fls(h) + 32;
+ return fls(x);
+}
+# 28 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/find.h" 1
+# 29 "include/asm-generic/bitops.h" 2
+
+
+
+
+
+# 1 "include/asm-generic/bitops/sched.h" 1
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 6 "include/asm-generic/bitops/sched.h" 2
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int sched_find_first_bit(const unsigned long *b)
+{
+
+
+
+
+
+ if (b[0])
+  return __ffs(b[0]);
+ if (b[1])
+  return __ffs(b[1]) + 32;
+ if (b[2])
+  return __ffs(b[2]) + 64;
+ return __ffs(b[3]) + 96;
+
+
+
+}
+# 35 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/ffs.h" 1
+# 12 "include/asm-generic/bitops/ffs.h"
+static inline __attribute__((always_inline)) int ffs(int x)
+{
+ int r = 1;
+
+ if (!x)
+  return 0;
+ if (!(x & 0xffff)) {
+  x >>= 16;
+  r += 16;
+ }
+ if (!(x & 0xff)) {
+  x >>= 8;
+  r += 8;
+ }
+ if (!(x & 0xf)) {
+  x >>= 4;
+  r += 4;
+ }
+ if (!(x & 3)) {
+  x >>= 2;
+  r += 2;
+ }
+ if (!(x & 1)) {
+  x >>= 1;
+  r += 1;
+ }
+ return r;
+}
+# 36 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/hweight.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/hweight.h" 2
+
+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);
+# 37 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/lock.h" 1
+# 38 "include/asm-generic/bitops.h" 2
+
+# 1 "include/asm-generic/bitops/atomic.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/atomic.h" 2
+# 65 "include/asm-generic/bitops/atomic.h"
+static inline __attribute__((always_inline)) void set_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long flags;
+
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0); } while (0);
+ *p |= mask;
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0); } while (0);
+}
+# 86 "include/asm-generic/bitops/atomic.h"
+static inline __attribute__((always_inline)) void clear_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long flags;
+
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0); } while (0);
+ *p &= ~mask;
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0); } while (0);
+}
+# 107 "include/asm-generic/bitops/atomic.h"
+static inline __attribute__((always_inline)) void change_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long flags;
+
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0); } while (0);
+ *p ^= mask;
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0); } while (0);
+}
+# 127 "include/asm-generic/bitops/atomic.h"
+static inline __attribute__((always_inline)) int test_and_set_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long old;
+ unsigned long flags;
+
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0); } while (0);
+ old = *p;
+ *p = old | mask;
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0); } while (0);
+
+ return (old & mask) != 0;
+}
+# 151 "include/asm-generic/bitops/atomic.h"
+static inline __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long old;
+ unsigned long flags;
+
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0); } while (0);
+ old = *p;
+ *p = old & ~mask;
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0); } while (0);
+
+ return (old & mask) != 0;
+}
+# 174 "include/asm-generic/bitops/atomic.h"
+static inline __attribute__((always_inline)) int test_and_change_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long old;
+ unsigned long flags;
+
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0); } while (0);
+ old = *p;
+ *p = old ^ mask;
+ do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0); } while (0);
+
+ return (old & mask) != 0;
+}
+# 40 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/non-atomic.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/non-atomic.h" 2
+# 15 "include/asm-generic/bitops/non-atomic.h"
+static inline __attribute__((always_inline)) void __set_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+
+ *p |= mask;
+}
+
+static inline __attribute__((always_inline)) void __clear_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+
+ *p &= ~mask;
+}
+# 40 "include/asm-generic/bitops/non-atomic.h"
+static inline __attribute__((always_inline)) void __change_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+
+ *p ^= mask;
+}
+# 57 "include/asm-generic/bitops/non-atomic.h"
+static inline __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long old = *p;
+
+ *p = old | mask;
+ return (old & mask) != 0;
+}
+# 76 "include/asm-generic/bitops/non-atomic.h"
+static inline __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long old = *p;
+
+ *p = old & ~mask;
+ return (old & mask) != 0;
+}
+
+
+static inline __attribute__((always_inline)) int __test_and_change_bit(int nr,
+         volatile unsigned long *addr)
+{
+ unsigned long mask = (1UL << ((nr) % 32));
+ unsigned long *p = ((unsigned long *)addr) + ((nr) / 32);
+ unsigned long old = *p;
+
+ *p = old ^ mask;
+ return (old & mask) != 0;
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int test_bit(int nr, const volatile unsigned long *addr)
+{
+ return 1UL & (addr[((nr) / 32)] >> (nr & (32 -1)));
+}
+# 41 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/ext2-non-atomic.h" 1
+
+
+
+# 1 "include/asm-generic/bitops/le.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/asm-generic/bitops/le.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/byteorder.h" 1
+# 1 "include/linux/byteorder/little_endian.h" 1
+# 12 "include/linux/byteorder/little_endian.h"
+# 1 "include/linux/swab.h" 1
+
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/swab.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/swab.h"
+# 1 "include/asm-generic/swab.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitsperlong.h" 1
+# 5 "include/asm-generic/swab.h" 2
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/swab.h" 2
+
+
+
+static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __arch_swahb32(__u32 xx)
+{
+ __u32 tmp;
+ __asm__("%1 = %0 >> 8 (V);\n\t"
+  "%0 = %0 << 8 (V);\n\t"
+  "%0 = %0 | %1;\n\t"
+  : "+d"(xx), "=&d"(tmp));
+ return xx;
+}
+
+
+static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __arch_swahw32(__u32 xx)
+{
+ __u32 rv;
+ __asm__("%0 = PACK(%1.L, %1.H);\n\t": "=d"(rv): "d"(xx));
+ return rv;
+}
+
+
+static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __arch_swab32(__u32 xx)
+{
+ return __arch_swahb32(__arch_swahw32(xx));
+}
+
+
+static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __arch_swab16(__u16 xx)
+{
+ __u32 xw = xx;
+ __asm__("%0 <<= 8;\n  %0.L = %0.L + %0.H (NS);\n": "+d"(xw));
+ return (__u16)xw;
+}
+# 7 "include/linux/swab.h" 2
+# 46 "include/linux/swab.h"
+static inline __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 val)
+{
+
+ return __arch_swab16(val);
+
+
+
+}
+
+static inline __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswab32(__u32 val)
+{
+
+ return __arch_swab32(val);
+
+
+
+}
+
+static inline __attribute__((always_inline)) __attribute__((__const__)) __u64 __fswab64(__u64 val)
+{
+
+
+
+ __u32 h = val >> 32;
+ __u32 l = val & ((1ULL << 32) - 1);
+ return (((__u64)__fswab32(l)) << 32) | ((__u64)(__fswab32(h)));
+
+
+
+}
+
+static inline __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswahw32(__u32 val)
+{
+
+ return __arch_swahw32(val);
+
+
+
+}
+
+static inline __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswahb32(__u32 val)
+{
+
+ return __arch_swahb32(val);
+
+
+
+}
+# 148 "include/linux/swab.h"
+static inline __attribute__((always_inline)) __u16 __swab16p(const __u16 *p)
+{
+
+
+
+ return (__builtin_constant_p((__u16)(*p)) ? ((__u16)( (((__u16)(*p) & (__u16)0x00ffU) << 8) | (((__u16)(*p) & (__u16)0xff00U) >> 8))) : __fswab16(*p));
+
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) __u32 __swab32p(const __u32 *p)
+{
+
+
+
+ return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x000000ffUL) << 24) | (((__u32)(*p) & (__u32)0x0000ff00UL) << 8) | (((__u32)(*p) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(*p) & (__u32)0xff000000UL) >> 24))) : __fswab32(*p));
+
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) __u64 __swab64p(const __u64 *p)
+{
+
+
+
+ return (__builtin_constant_p((__u64)(*p)) ? ((__u64)( (((__u64)(*p) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(*p) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(*p) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(*p) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(*p) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(*p) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(*p) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(*p) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(*p));
+
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) __u32 __swahw32p(const __u32 *p)
+{
+
+
+
+ return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x0000ffffUL) << 16) | (((__u32)(*p) & (__u32)0xffff0000UL) >> 16))) : __fswahw32(*p));
+
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) __u32 __swahb32p(const __u32 *p)
+{
+
+
+
+ return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(*p) & (__u32)0xff00ff00UL) >> 8))) : __fswahb32(*p));
+
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) void __swab16s(__u16 *p)
+{
+
+
+
+ *p = __swab16p(p);
+
+}
+
+
+
+
+static inline __attribute__((always_inline)) void __swab32s(__u32 *p)
+{
+
+
+
+ *p = __swab32p(p);
+
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) void __swab64s(__u64 *p)
+{
+
+
+
+ *p = __swab64p(p);
+
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void __swahw32s(__u32 *p)
+{
+
+
+
+ *p = __swahw32p(p);
+
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void __swahb32s(__u32 *p)
+{
+
+
+
+ *p = __swahb32p(p);
+
+}
+# 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)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val))) ? ((__u64)( (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__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)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val))));
+}
+# 106 "include/linux/byteorder/little_endian.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/byteorder.h" 2
+# 6 "include/asm-generic/bitops/le.h" 2
+# 5 "include/asm-generic/bitops/ext2-non-atomic.h" 2
+# 42 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/ext2-atomic.h" 1
+# 43 "include/asm-generic/bitops.h" 2
+# 1 "include/asm-generic/bitops/minix.h" 1
+# 44 "include/asm-generic/bitops.h" 2
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/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);
+}
+# 123 "include/linux/bitops.h"
+static inline __attribute__((always_inline)) unsigned long __ffs64(u64 word)
+{
+
+ if (((u32)word) == 0UL)
+  return __ffs((u32)(word >> 32)) + 32;
+
+
+
+ return __ffs((unsigned long)word);
+}
+# 166 "include/linux/bitops.h"
+extern unsigned long find_last_bit(const unsigned long *addr,
+       unsigned long size);
+# 178 "include/linux/bitops.h"
+extern unsigned long find_next_bit(const unsigned long *addr,
+       unsigned long size, unsigned long offset);
+# 188 "include/linux/bitops.h"
+extern unsigned long find_next_zero_bit(const unsigned long *addr,
+     unsigned long size,
+     unsigned long offset);
+# 16 "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/linux/ratelimit.h" 1
+
+
+# 1 "include/linux/param.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/param.h" 1
+# 1 "include/asm-generic/param.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/param.h" 2
+# 5 "include/linux/param.h" 2
+# 4 "include/linux/ratelimit.h" 2
+
+
+
+
+struct ratelimit_state {
+ int interval;
+ int burst;
+ int printed;
+ int missed;
+ unsigned long begin;
+};
+
+
+
+
+extern int __ratelimit(struct ratelimit_state *rs);
+# 19 "include/linux/kernel.h" 2
+# 1 "include/linux/dynamic_debug.h" 1
+
+
+
+
+
+
+
+extern long long dynamic_debug_enabled;
+extern long long dynamic_debug_enabled2;
+
+
+
+
+
+
+struct _ddebug {
+
+
+
+
+ const char *modname;
+ const char *function;
+ const char *filename;
+ const char *format;
+ char primary_hash;
+ char secondary_hash;
+ unsigned int lineno:24;
+
+
+
+
+
+
+
+ unsigned int flags:8;
+} __attribute__((aligned(8)));
+
+
+int ddebug_add_module(struct _ddebug *tab, unsigned int n,
+    const char *modname);
+# 79 "include/linux/dynamic_debug.h"
+static inline __attribute__((always_inline)) int ddebug_remove_module(char *mod)
+{
+ return 0;
+}
+# 20 "include/linux/kernel.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/byteorder.h" 1
+# 21 "include/linux/kernel.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bug.h" 1
+# 66 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bug.h"
+# 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;
+};
+# 61 "include/asm-generic/bug.h"
+extern void warn_slowpath_fmt(const char *file, const int line,
+  const char *fmt, ...) __attribute__((format(printf, 3, 4)));
+extern void warn_slowpath_null(const char *file, const int line);
+# 67 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bug.h" 2
+# 22 "include/linux/kernel.h" 2
+
+extern const char linux_banner[];
+extern const char linux_proc_banner[];
+# 62 "include/linux/kernel.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/div64.h" 1
+# 1 "include/asm-generic/div64.h" 1
+# 35 "include/asm-generic/div64.h"
+extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/div64.h" 2
+# 63 "include/linux/kernel.h" 2
+# 109 "include/linux/kernel.h"
+extern int console_printk[];
+
+
+
+
+
+
+struct completion;
+struct pt_regs;
+struct user;
+
+
+extern int _cond_resched(void);
+
+
+
+
+
+
+  void __might_sleep(char *file, int line, int preempt_offset);
+# 156 "include/linux/kernel.h"
+static inline __attribute__((always_inline)) void might_fault(void)
+{
+ do { __might_sleep("include/linux/kernel.h", 158, 0); _cond_resched(); } while (0);
+}
+
+
+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(const char *ptr, char **retptr);
+
+extern int core_kernel_text(unsigned long addr);
+extern int __kernel_text_address(unsigned long addr);
+extern int kernel_text_address(unsigned long addr);
+extern int func_ptr_is_kernel_text(void *ptr);
+
+struct pid;
+extern struct pid *session_of_pgrp(struct pid *pgrp);
+# 239 "include/linux/kernel.h"
+ 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 struct ratelimit_state printk_ratelimit_state;
+extern int printk_ratelimit(void);
+extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
+       unsigned int interval_msec);
+
+extern int printk_delay_msec;
+# 263 "include/linux/kernel.h"
+void log_buf_kexec_setup(void);
+# 284 "include/linux/kernel.h"
+extern int printk_needs_cpu(int cpu);
+extern void printk_tick(void);
+
+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 panic_on_io_nmi;
+extern const char *print_tainted(void);
+extern void add_taint(unsigned flag);
+extern int test_taint(unsigned flag);
+extern unsigned long get_taint(void);
+extern int root_mountflags;
+
+
+extern enum system_states {
+ SYSTEM_BOOTING,
+ SYSTEM_RUNNING,
+ SYSTEM_HALT,
+ SYSTEM_POWER_OFF,
+ SYSTEM_RESTART,
+ SYSTEM_SUSPEND_DISK,
+} system_state;
+# 338 "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;
+}
+# 429 "include/linux/kernel.h"
+void tracing_on(void);
+void tracing_off(void);
+
+void tracing_off_permanent(void);
+int tracing_is_on(void);
+
+
+
+
+
+
+
+extern void tracing_start(void);
+extern void tracing_stop(void);
+extern void ftrace_off_permanent(void);
+
+extern void
+ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
+
+static inline __attribute__((always_inline)) void __attribute__ ((format (printf, 1, 2)))
+____trace_printk_check_format(const char *fmt, ...)
+{
+}
+# 488 "include/linux/kernel.h"
+extern int
+__trace_bprintk(unsigned long ip, const char *fmt, ...)
+ __attribute__ ((format (printf, 2, 3)));
+
+extern int
+__trace_printk(unsigned long ip, const char *fmt, ...)
+ __attribute__ ((format (printf, 2, 3)));
+# 513 "include/linux/kernel.h"
+extern int
+__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
+
+extern int
+__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
+
+extern void ftrace_dump(void);
+# 657 "include/linux/kernel.h"
+struct sysinfo;
+extern int do_sysinfo(struct sysinfo *info);
+# 669 "include/linux/kernel.h"
+struct sysinfo {
+ long uptime;
+ unsigned long loads[3];
+ unsigned long totalram;
+ unsigned long freeram;
+ unsigned long sharedram;
+ unsigned long bufferram;
+ unsigned long totalswap;
+ unsigned long freeswap;
+ unsigned short procs;
+ unsigned short pad;
+ unsigned long totalhigh;
+ unsigned long freehigh;
+ unsigned int mem_unit;
+ char _f[20-2*sizeof(long)-sizeof(int)];
+};
+# 5 "include/linux/cache.h" 2
+# 8 "include/linux/time.h" 2
+# 1 "include/linux/seqlock.h" 1
+# 29 "include/linux/seqlock.h"
+# 1 "include/linux/spinlock.h" 1
+# 50 "include/linux/spinlock.h"
+# 1 "include/linux/preempt.h" 1
+# 9 "include/linux/preempt.h"
+# 1 "include/linux/thread_info.h" 1
+# 12 "include/linux/thread_info.h"
+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;
+   u32 *uaddr2;
+  } futex;
+
+  struct {
+   clockid_t index;
+   struct timespec *rmtp;
+
+
+
+   u64 expires;
+  } nanosleep;
+
+  struct {
+   struct pollfd *ufds;
+   int nfds;
+   int has_timeout;
+   unsigned long tv_sec;
+   unsigned long tv_nsec;
+  } poll;
+ };
+};
+
+extern long do_no_restart_syscall(struct restart_block *parm);
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/thread_info.h" 1
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/thread_info.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/page.h" 1
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/page.h"
+# 1 "include/asm-generic/page.h" 1
+# 23 "include/asm-generic/page.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/setup.h" 1
+# 1 "include/asm-generic/setup.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/setup.h" 2
+# 24 "include/asm-generic/page.h" 2
+# 39 "include/asm-generic/page.h"
+typedef struct {
+ unsigned long pte;
+} pte_t;
+typedef struct {
+ unsigned long pmd[16];
+} pmd_t;
+typedef struct {
+ unsigned long pgd;
+} pgd_t;
+typedef struct {
+ unsigned long pgprot;
+} pgprot_t;
+typedef struct page *pgtable_t;
+# 63 "include/asm-generic/page.h"
+extern unsigned long memory_start;
+extern unsigned long memory_end;
+# 96 "include/asm-generic/page.h"
+# 1 "include/asm-generic/memory_model.h" 1
+# 97 "include/asm-generic/page.h" 2
+# 1 "include/asm-generic/getorder.h" 1
+# 9 "include/asm-generic/getorder.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;
+}
+# 98 "include/asm-generic/page.h" 2
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/page.h" 2
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/thread_info.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/entry.h" 1
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/entry.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/setup.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/entry.h" 2
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/thread_info.h" 2
+# 31 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/thread_info.h"
+typedef unsigned long mm_segment_t;
+
+
+
+
+
+
+struct thread_info {
+ struct task_struct *task;
+ struct exec_domain *exec_domain;
+ unsigned long flags;
+ int cpu;
+ int preempt_count;
+ mm_segment_t addr_limit;
+ struct restart_block restart_block;
+
+ struct l1_scratch_task_info l1_task_info;
+
+};
+# 72 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/thread_info.h"
+__attribute__((__const__))
+static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
+{
+ struct thread_info *ti;
+      __asm__("%0 = sp;" : "=da"(ti) :
+ );
+ return (struct thread_info *)((long)ti & ~((long)8192 -1));
+}
+# 57 "include/linux/thread_info.h" 2
+# 65 "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 test_bit(flag, (unsigned long *)&ti->flags);
+}
+# 122 "include/linux/thread_info.h"
+static inline __attribute__((always_inline)) void set_restore_sigmask(void)
+{
+ set_ti_thread_flag(current_thread_info(), 5);
+ set_ti_thread_flag(current_thread_info(), 1);
+}
+# 10 "include/linux/preempt.h" 2
+# 51 "include/linux/spinlock.h" 2
+
+
+
+
+# 1 "include/linux/stringify.h" 1
+# 56 "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_ip(unsigned long ip);
+# 57 "include/linux/spinlock.h" 2
+# 80 "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
+# 17 "include/linux/spinlock_types_up.h"
+typedef struct {
+ volatile unsigned int slock;
+} raw_spinlock_t;
+# 31 "include/linux/spinlock_types_up.h"
+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;
+
+
+
+
+
+# 1 "include/linux/debug_locks.h" 1
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/atomic.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/atomic.h"
+# 1 "include/asm-generic/atomic.h" 1
+# 58 "include/asm-generic/atomic.h"
+static inline __attribute__((always_inline)) int atomic_add_return(int i, atomic_t *v)
+{
+ unsigned long flags;
+ int temp;
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ temp = v->counter;
+ temp += i;
+ v->counter = temp;
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+
+ return temp;
+}
+# 80 "include/asm-generic/atomic.h"
+static inline __attribute__((always_inline)) int atomic_sub_return(int i, atomic_t *v)
+{
+ unsigned long flags;
+ int temp;
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ temp = v->counter;
+ temp -= i;
+ v->counter = temp;
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+
+ return temp;
+}
+
+static inline __attribute__((always_inline)) int atomic_add_negative(int i, atomic_t *v)
+{
+ return atomic_add_return(i, v) < 0;
+}
+
+static inline __attribute__((always_inline)) void atomic_add(int i, atomic_t *v)
+{
+ atomic_add_return(i, v);
+}
+
+static inline __attribute__((always_inline)) void atomic_sub(int i, atomic_t *v)
+{
+ atomic_sub_return(i, v);
+}
+
+static inline __attribute__((always_inline)) void atomic_inc(atomic_t *v)
+{
+ atomic_add_return(1, v);
+}
+
+static inline __attribute__((always_inline)) void atomic_dec(atomic_t *v)
+{
+ atomic_sub_return(1, v);
+}
+# 137 "include/asm-generic/atomic.h"
+static inline __attribute__((always_inline)) void atomic_clear_mask(unsigned long mask, unsigned long *addr)
+{
+ unsigned long flags;
+
+ mask = ~mask;
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ *addr &= mask;
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+}
+# 162 "include/asm-generic/atomic.h"
+# 1 "include/asm-generic/atomic-long.h" 1
+# 11 "include/asm-generic/atomic-long.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 12 "include/asm-generic/atomic-long.h" 2
+# 141 "include/asm-generic/atomic-long.h"
+typedef atomic_t atomic_long_t;
+
+
+static inline __attribute__((always_inline)) long atomic_long_read(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (long)((v)->counter);
+}
+
+static inline __attribute__((always_inline)) void atomic_long_set(atomic_long_t *l, long i)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ (((v)->counter) = (i));
+}
+
+static inline __attribute__((always_inline)) void atomic_long_inc(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ atomic_inc(v);
+}
+
+static inline __attribute__((always_inline)) void atomic_long_dec(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ atomic_dec(v);
+}
+
+static inline __attribute__((always_inline)) void atomic_long_add(long i, atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ atomic_add(i, v);
+}
+
+static inline __attribute__((always_inline)) void atomic_long_sub(long i, atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ atomic_sub(i, v);
+}
+
+static inline __attribute__((always_inline)) int atomic_long_sub_and_test(long i, atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (atomic_sub_return((i), (v)) == 0);
+}
+
+static inline __attribute__((always_inline)) int atomic_long_dec_and_test(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (atomic_sub_return(1, (v)) == 0);
+}
+
+static inline __attribute__((always_inline)) int atomic_long_inc_and_test(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (atomic_add_return(1, (v)) == 0);
+}
+
+static inline __attribute__((always_inline)) int atomic_long_add_negative(long i, atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return atomic_add_negative(i, v);
+}
+
+static inline __attribute__((always_inline)) long atomic_long_add_return(long i, atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (long)atomic_add_return(i, v);
+}
+
+static inline __attribute__((always_inline)) long atomic_long_sub_return(long i, atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (long)atomic_sub_return(i, v);
+}
+
+static inline __attribute__((always_inline)) long atomic_long_inc_return(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (long)atomic_add_return(1, (v));
+}
+
+static inline __attribute__((always_inline)) long atomic_long_dec_return(atomic_long_t *l)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (long)atomic_sub_return(1, (v));
+}
+
+static inline __attribute__((always_inline)) long atomic_long_add_unless(atomic_long_t *l, long a, long u)
+{
+ atomic_t *v = (atomic_t *)l;
+
+ return (long)({ int c, old; c = ((v)->counter); while (c != (u) && (old = (((__typeof__(*((&(((v))->counter)))))__cmpxchg_local_generic(((&(((v))->counter))), (unsigned long)(((c))), (unsigned long)(((c + (a)))), sizeof(*((&(((v))->counter)))))))) != c) c = old; c != (u); });
+}
+# 163 "include/asm-generic/atomic.h" 2
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/atomic.h" 2
+# 6 "include/linux/debug_locks.h" 2
+
+
+struct task_struct;
+
+extern int debug_locks;
+extern int debug_locks_silent;
+
+
+static inline __attribute__((always_inline)) int __debug_locks_off(void)
+{
+ return ((__typeof__(*(&debug_locks)))__xchg((unsigned long)(0), (&debug_locks), sizeof(*(&debug_locks))));
+}
+
+
+
+
+extern int debug_locks_off(void);
+# 43 "include/linux/debug_locks.h"
+  extern void locking_selftest(void);
+
+
+
+
+struct task_struct;
+
+
+extern void debug_show_all_locks(void);
+extern void __debug_show_held_locks(struct task_struct *task);
+extern void debug_show_held_locks(struct task_struct *task);
+extern void debug_check_no_locks_freed(const void *from, unsigned long len);
+extern void debug_check_no_locks_held(struct task_struct *task);
+# 20 "include/linux/lockdep.h" 2
+# 1 "include/linux/stacktrace.h" 1
+
+
+
+struct task_struct;
+
+
+struct task_struct;
+
+struct stack_trace {
+ unsigned int nr_entries, max_entries;
+ unsigned long *entries;
+ int skip;
+};
+
+extern void save_stack_trace(struct stack_trace *trace);
+extern void save_stack_trace_bp(struct stack_trace *trace, unsigned long bp);
+extern void save_stack_trace_tsk(struct task_struct *tsk,
+    struct stack_trace *trace);
+
+extern void print_stack_trace(struct stack_trace *trace, int spaces);
+# 21 "include/linux/lockdep.h" 2
+# 35 "include/linux/lockdep.h"
+struct lockdep_subclass_key {
+ char __one_byte;
+} __attribute__ ((__packed__));
+
+struct lock_class_key {
+ struct lockdep_subclass_key subkeys[8UL];
+};
+
+
+
+
+
+
+struct lock_class {
+
+
+
+ struct list_head hash_entry;
+
+
+
+
+ struct list_head lock_entry;
+
+ struct lockdep_subclass_key *key;
+ unsigned int subclass;
+ unsigned int dep_gen_id;
+
+
+
+
+ unsigned long usage_mask;
+ struct stack_trace usage_traces[(1+3*4)];
+
+
+
+
+
+
+ struct list_head locks_after, locks_before;
+
+
+
+
+
+ unsigned int version;
+
+
+
+
+ unsigned long ops;
+
+ const char *name;
+ int name_version;
+
+
+
+
+
+};
+# 133 "include/linux/lockdep.h"
+struct lockdep_map {
+ struct lock_class_key *key;
+ struct lock_class *class_cache;
+ const char *name;
+
+
+
+
+};
+
+
+
+
+
+struct lock_list {
+ struct list_head entry;
+ struct lock_class *class;
+ struct stack_trace trace;
+ int distance;
+
+
+
+
+
+ struct lock_list *parent;
+};
+
+
+
+
+struct lock_chain {
+ u8 irq_context;
+ u8 depth;
+ u16 base;
+ struct list_head entry;
+ u64 chain_key;
+};
+# 179 "include/linux/lockdep.h"
+struct held_lock {
+# 194 "include/linux/lockdep.h"
+ u64 prev_chain_key;
+ unsigned long acquire_ip;
+ struct lockdep_map *instance;
+ struct lockdep_map *nest_lock;
+
+
+
+
+ unsigned int class_idx:13;
+# 216 "include/linux/lockdep.h"
+ unsigned int irq_context:2;
+ unsigned int trylock:1;
+
+ unsigned int read:2;
+ unsigned int check:2;
+ unsigned int hardirqs_off:1;
+ unsigned int references:11;
+};
+
+
+
+
+extern void lockdep_init(void);
+extern void lockdep_info(void);
+extern void lockdep_reset(void);
+extern void lockdep_reset_lock(struct lockdep_map *lock);
+extern void lockdep_free_key_range(void *start, unsigned long size);
+extern void lockdep_sys_exit(void);
+
+extern void lockdep_off(void);
+extern void lockdep_on(void);
+
+
+
+
+
+
+
+extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
+        struct lock_class_key *key, int subclass);
+# 274 "include/linux/lockdep.h"
+static inline __attribute__((always_inline)) int lockdep_match_key(struct lockdep_map *lock,
+        struct lock_class_key *key)
+{
+ return lock->key == key;
+}
+# 295 "include/linux/lockdep.h"
+extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
+    int trylock, int read, int check,
+    struct lockdep_map *nest_lock, unsigned long ip);
+
+extern void lock_release(struct lockdep_map *lock, int nested,
+    unsigned long ip);
+
+
+
+extern int lock_is_held(struct lockdep_map *lock);
+
+extern void lock_set_class(struct lockdep_map *lock, const char *name,
+      struct lock_class_key *key, unsigned int subclass,
+      unsigned long ip);
+
+static inline __attribute__((always_inline)) void lock_set_subclass(struct lockdep_map *lock,
+  unsigned int subclass, unsigned long ip)
+{
+ lock_set_class(lock, lock->name, lock->key, subclass, ip);
+}
+
+extern void lockdep_set_current_reclaim_state(gfp_t gfp_mask);
+extern void lockdep_clear_current_reclaim_state(void);
+extern void lockdep_trace_alloc(gfp_t mask);
+# 416 "include/linux/lockdep.h"
+extern void early_init_irq_lock_class(void);
+# 428 "include/linux/lockdep.h"
+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;
+
+
+
+
+ unsigned int magic, owner_cpu;
+ void *owner;
+
+
+ struct lockdep_map dep_map;
+
+} spinlock_t;
+
+
+
+typedef struct {
+ raw_rwlock_t raw_lock;
+
+
+
+
+ unsigned int magic, owner_cpu;
+ void *owner;
+
+
+ struct lockdep_map dep_map;
+
+} rwlock_t;
+# 81 "include/linux/spinlock.h" 2
+
+extern int __attribute__((section(".spinlock.text"))) generic__raw_read_trylock(raw_rwlock_t *lock);
+
+
+
+
+
+
+
+# 1 "include/linux/spinlock_up.h" 1
+# 23 "include/linux/spinlock_up.h"
+static inline __attribute__((always_inline)) void __raw_spin_lock(raw_spinlock_t *lock)
+{
+ lock->slock = 0;
+}
+
+static inline __attribute__((always_inline)) void
+__raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
+{
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ lock->slock = 0;
+}
+
+static inline __attribute__((always_inline)) int __raw_spin_trylock(raw_spinlock_t *lock)
+{
+ char oldval = lock->slock;
+
+ lock->slock = 0;
+
+ return oldval > 0;
+}
+
+static inline __attribute__((always_inline)) void __raw_spin_unlock(raw_spinlock_t *lock)
+{
+ lock->slock = 1;
+}
+# 91 "include/linux/spinlock.h" 2
+
+
+
+  extern void __spin_lock_init(spinlock_t *lock, const char *name,
+          struct lock_class_key *key);
+# 109 "include/linux/spinlock.h"
+  extern void __rwlock_init(rwlock_t *lock, const char *name,
+       struct lock_class_key *key);
+# 137 "include/linux/spinlock.h"
+static inline __attribute__((always_inline)) void smp_mb__after_lock(void) { __asm__ __volatile__("": : :"memory"); }
+# 147 "include/linux/spinlock.h"
+ extern void _raw_spin_lock(spinlock_t *lock);
+
+ extern int _raw_spin_trylock(spinlock_t *lock);
+ extern void _raw_spin_unlock(spinlock_t *lock);
+ extern void _raw_read_lock(rwlock_t *lock);
+
+ extern int _raw_read_trylock(rwlock_t *lock);
+ extern void _raw_read_unlock(rwlock_t *lock);
+ extern void _raw_write_lock(rwlock_t *lock);
+
+ extern int _raw_write_trylock(rwlock_t *lock);
+ extern void _raw_write_unlock(rwlock_t *lock);
+# 330 "include/linux/spinlock.h"
+extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
+# 344 "include/linux/spinlock.h"
+# 1 "include/linux/spinlock_api_smp.h" 1
+# 18 "include/linux/spinlock_api_smp.h"
+int in_lock_functions(unsigned long addr);
+
+
+
+void __attribute__((section(".spinlock.text"))) _spin_lock(spinlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _spin_lock_nested(spinlock_t *lock, int subclass)
+       ;
+void __attribute__((section(".spinlock.text"))) _spin_lock_nest_lock(spinlock_t *lock, struct lockdep_map *map)
+       ;
+void __attribute__((section(".spinlock.text"))) _read_lock(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _write_lock(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _spin_lock_bh(spinlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _read_lock_bh(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _write_lock_bh(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _spin_lock_irq(spinlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _read_lock_irq(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _write_lock_irq(rwlock_t *lock) ;
+unsigned long __attribute__((section(".spinlock.text"))) _spin_lock_irqsave(spinlock_t *lock)
+       ;
+unsigned long __attribute__((section(".spinlock.text"))) _spin_lock_irqsave_nested(spinlock_t *lock, int subclass)
+       ;
+unsigned long __attribute__((section(".spinlock.text"))) _read_lock_irqsave(rwlock_t *lock)
+       ;
+unsigned long __attribute__((section(".spinlock.text"))) _write_lock_irqsave(rwlock_t *lock)
+       ;
+int __attribute__((section(".spinlock.text"))) _spin_trylock(spinlock_t *lock);
+int __attribute__((section(".spinlock.text"))) _read_trylock(rwlock_t *lock);
+int __attribute__((section(".spinlock.text"))) _write_trylock(rwlock_t *lock);
+int __attribute__((section(".spinlock.text"))) _spin_trylock_bh(spinlock_t *lock);
+void __attribute__((section(".spinlock.text"))) _spin_unlock(spinlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _read_unlock(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _write_unlock(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _spin_unlock_bh(spinlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _read_unlock_bh(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _write_unlock_bh(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _spin_unlock_irq(spinlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _read_unlock_irq(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _write_unlock_irq(rwlock_t *lock) ;
+void __attribute__((section(".spinlock.text"))) _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
+       ;
+void __attribute__((section(".spinlock.text"))) _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+       ;
+void __attribute__((section(".spinlock.text"))) _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+       ;
+# 194 "include/linux/spinlock_api_smp.h"
+static inline __attribute__((always_inline)) int __spin_trylock(spinlock_t *lock)
+{
+ do { } while (0);
+ if (_raw_spin_trylock(lock)) {
+  lock_acquire(&lock->dep_map, 0, 1, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+  return 1;
+ }
+ do { } while (0);
+ return 0;
+}
+
+static inline __attribute__((always_inline)) int __read_trylock(rwlock_t *lock)
+{
+ do { } while (0);
+ if (_raw_read_trylock(lock)) {
+  lock_acquire(&lock->dep_map, 0, 1, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+  return 1;
+ }
+ do { } while (0);
+ return 0;
+}
+
+static inline __attribute__((always_inline)) int __write_trylock(rwlock_t *lock)
+{
+ do { } while (0);
+ if (_raw_write_trylock(lock)) {
+  lock_acquire(&lock->dep_map, 0, 1, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+  return 1;
+ }
+ do { } while (0);
+ return 0;
+}
+# 234 "include/linux/spinlock_api_smp.h"
+static inline __attribute__((always_inline)) void __read_lock(rwlock_t *lock)
+{
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_read_lock(lock);
+}
+
+static inline __attribute__((always_inline)) unsigned long __spin_lock_irqsave(spinlock_t *lock)
+{
+ unsigned long flags;
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+
+
+
+
+
+
+ _raw_spin_lock(lock);
+
+
+
+ return flags;
+}
+
+static inline __attribute__((always_inline)) void __spin_lock_irq(spinlock_t *lock)
+{
+ do { raw_local_irq_disable(); do { } while (0); } while (0);
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_spin_lock(lock);
+}
+
+static inline __attribute__((always_inline)) void __spin_lock_bh(spinlock_t *lock)
+{
+ local_bh_disable();
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_spin_lock(lock);
+}
+
+static inline __attribute__((always_inline)) unsigned long __read_lock_irqsave(rwlock_t *lock)
+{
+ unsigned long flags;
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ (_raw_read_lock)((lock));
+
+ return flags;
+}
+
+static inline __attribute__((always_inline)) void __read_lock_irq(rwlock_t *lock)
+{
+ do { raw_local_irq_disable(); do { } while (0); } while (0);
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_read_lock(lock);
+}
+
+static inline __attribute__((always_inline)) void __read_lock_bh(rwlock_t *lock)
+{
+ local_bh_disable();
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_read_lock(lock);
+}
+
+static inline __attribute__((always_inline)) unsigned long __write_lock_irqsave(rwlock_t *lock)
+{
+ unsigned long flags;
+
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ (_raw_write_lock)((lock));
+
+ return flags;
+}
+
+static inline __attribute__((always_inline)) void __write_lock_irq(rwlock_t *lock)
+{
+ do { raw_local_irq_disable(); do { } while (0); } while (0);
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_write_lock(lock);
+}
+
+static inline __attribute__((always_inline)) void __write_lock_bh(rwlock_t *lock)
+{
+ local_bh_disable();
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_write_lock(lock);
+}
+
+static inline __attribute__((always_inline)) void __spin_lock(spinlock_t *lock)
+{
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_spin_lock(lock);
+}
+
+static inline __attribute__((always_inline)) void __write_lock(rwlock_t *lock)
+{
+ do { } while (0);
+ lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+ _raw_write_lock(lock);
+}
+
+
+
+static inline __attribute__((always_inline)) void __spin_unlock(spinlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_spin_unlock(lock);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __write_unlock(rwlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_write_unlock(lock);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __read_unlock(rwlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_read_unlock(lock);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __spin_unlock_irqrestore(spinlock_t *lock,
+         unsigned long flags)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_spin_unlock(lock);
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __spin_unlock_irq(spinlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_spin_unlock(lock);
+ do { do { } while (0); raw_local_irq_enable(); } while (0);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __spin_unlock_bh(spinlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_spin_unlock(lock);
+ do { } while (0);
+ local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+}
+
+static inline __attribute__((always_inline)) void __read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_read_unlock(lock);
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __read_unlock_irq(rwlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_read_unlock(lock);
+ do { do { } while (0); raw_local_irq_enable(); } while (0);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __read_unlock_bh(rwlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_read_unlock(lock);
+ do { } while (0);
+ local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+}
+
+static inline __attribute__((always_inline)) void __write_unlock_irqrestore(rwlock_t *lock,
+          unsigned long flags)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_write_unlock(lock);
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __write_unlock_irq(rwlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_write_unlock(lock);
+ do { do { } while (0); raw_local_irq_enable(); } while (0);
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __write_unlock_bh(rwlock_t *lock)
+{
+ lock_release(&lock->dep_map, 1, (unsigned long)__builtin_return_address(0));
+ _raw_write_unlock(lock);
+ do { } while (0);
+ local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+}
+
+static inline __attribute__((always_inline)) int __spin_trylock_bh(spinlock_t *lock)
+{
+ local_bh_disable();
+ do { } while (0);
+ if (_raw_spin_trylock(lock)) {
+  lock_acquire(&lock->dep_map, 0, 1, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));
+  return 1;
+ }
+ do { } while (0);
+ local_bh_enable_ip((unsigned long)__builtin_return_address(0));
+ return 0;
+}
+# 345 "include/linux/spinlock.h" 2
+# 30 "include/linux/seqlock.h" 2
+
+
+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)
+{
+ _spin_lock(&sl->lock);
+ ++sl->sequence;
+ __asm__ __volatile__("": : :"memory");
+}
+
+static inline __attribute__((always_inline)) void write_sequnlock(seqlock_t *sl)
+{
+ __asm__ __volatile__("": : :"memory");
+ sl->sequence++;
+ _spin_unlock(&sl->lock);
+}
+
+static inline __attribute__((always_inline)) int write_tryseqlock(seqlock_t *sl)
+{
+ int ret = (_spin_trylock(&sl->lock));
+
+ if (ret) {
+  ++sl->sequence;
+  __asm__ __volatile__("": : :"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)) {
+  __asm__ __volatile__("": : :"memory");
+  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)) {
+  __asm__ __volatile__("": : :"memory");
+  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++;
+}
+# 9 "include/linux/time.h" 2
+# 1 "include/linux/math64.h" 1
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/div64.h" 1
+# 6 "include/linux/math64.h" 2
+# 41 "include/linux/math64.h"
+static inline __attribute__((always_inline)) u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
+{
+ *remainder = ({ uint32_t __base = (divisor); uint32_t __rem; (void)(((typeof((dividend)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((dividend) >> 32) == 0), 1)) { __rem = (uint32_t)(dividend) % __base; (dividend) = (uint32_t)(dividend) / __base; } else __rem = __div64_32(&(dividend), __base); __rem; });
+ return dividend;
+}
+
+
+
+extern s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder);
+
+
+
+extern u64 div64_u64(u64 dividend, u64 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);
+}
+
+
+u32 iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder);
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) u32
+__iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder)
+{
+ u32 ret = 0;
+
+ while (dividend >= divisor) {
+
+
+  asm("" : "+rm"(dividend));
+
+  dividend -= divisor;
+  ret++;
+ }
+
+ *remainder = dividend;
+
+ return ret;
+}
+# 10 "include/linux/time.h" 2
+
+
+
+
+struct timespec {
+ __kernel_time_t tv_sec;
+ long tv_nsec;
+};
+
+
+struct timeval {
+ __kernel_time_t tv_sec;
+ __kernel_suseconds_t tv_usec;
+};
+
+struct timezone {
+ int tz_minuteswest;
+ int tz_dsttime;
+};
+
+
+
+extern struct timezone sys_tz;
+# 45 "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 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, s64 nsec);
+extern struct timespec timespec_add_safe(const struct timespec lhs,
+      const struct timespec rhs);
+
+
+
+
+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 void read_persistent_clock(struct timespec *ts);
+extern void read_boot_clock(struct timespec *ts);
+extern int update_persistent_clock(struct timespec now);
+extern int no_sync_cmos_clock ;
+void timekeeping_init(void);
+extern int timekeeping_suspended;
+
+unsigned long get_seconds(void);
+struct timespec current_kernel_time(void);
+struct timespec __current_kernel_time(void);
+struct timespec get_monotonic_coarse(void);
+# 131 "include/linux/time.h"
+static inline __attribute__((always_inline)) u32 arch_gettimeoffset(void) { return 0; }
+
+
+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 getrawmonotonic(struct timespec *ts);
+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);
+extern void timekeeping_leap_insert(int leapsecond);
+
+struct tms;
+extern void do_sys_times(struct tms *);
+
+
+
+
+
+struct tm {
+
+
+
+
+ int tm_sec;
+
+ int tm_min;
+
+ int tm_hour;
+
+ int tm_mday;
+
+ int tm_mon;
+
+ long tm_year;
+
+ int tm_wday;
+
+ int tm_yday;
+};
+
+void time_to_tm(time_t totalsecs, int offset, struct tm *result);
+# 193 "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;
+}
+# 205 "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);
+# 235 "include/linux/time.h"
+static inline __attribute__((always_inline)) __attribute__((always_inline)) void timespec_add_ns(struct timespec *a, u64 ns)
+{
+ a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, 1000000000L, &ns);
+ a->tv_nsec = ns;
+}
+# 258 "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
+# 22 "include/linux/kmod.h"
+# 1 "include/linux/gfp.h" 1
+
+
+
+# 1 "include/linux/mmzone.h" 1
+# 9 "include/linux/mmzone.h"
+# 1 "include/linux/wait.h" 1
+# 26 "include/linux/wait.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/current.h" 1
+# 1 "include/asm-generic/current.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/current.h" 2
+# 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 flags, void *key);
+int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, 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, struct lock_class_key *);
+# 98 "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);
+}
+
+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);
+void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
+void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr,
+   void *key);
+void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
+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);
+void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,
+   unsigned int mode, void *key);
+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);
+# 489 "include/linux/wait.h"
+static inline __attribute__((always_inline)) int wait_on_bit(void *word, int bit,
+    int (*action)(void *), unsigned mode)
+{
+ if (!test_bit(bit, word))
+  return 0;
+ return out_of_line_wait_on_bit(word, bit, action, mode);
+}
+# 513 "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/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
+# 131 "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[];
+
+
+typedef void (*ctor_fn_t)(void);
+
+
+extern int do_one_initcall(initcall_t fn);
+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);
+# 15 "include/linux/mmzone.h" 2
+
+# 1 "include/linux/nodemask.h" 1
+# 95 "include/linux/nodemask.h"
+# 1 "include/linux/bitmap.h" 1
+
+
+
+
+
+
+
+# 1 "include/linux/string.h" 1
+# 15 "include/linux/string.h"
+extern char *strndup_user(const char *, long);
+extern void *memdup_user(const void *, size_t);
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/string.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/string.h"
+extern inline __attribute__((always_inline)) char *strcpy(char *dest, const char *src)
+{
+ char *xdest = dest;
+ char temp = 0;
+
+ __asm__ __volatile__ (
+  "1:"
+  "%2 = B [%1++] (Z);"
+  "B [%0++] = %2;"
+  "CC = %2;"
+  "if cc jump 1b (bp);"
+  : "+&a" (dest), "+&a" (src), "=&d" (temp)
+  :
+  : "memory", "CC");
+
+ return xdest;
+}
+
+
+extern inline __attribute__((always_inline)) char *strncpy(char *dest, const char *src, size_t n)
+{
+ char *xdest = dest;
+ char temp = 0;
+
+ if (n == 0)
+  return xdest;
+
+ __asm__ __volatile__ (
+  "1:"
+  "%3 = B [%1++] (Z);"
+  "B [%0++] = %3;"
+  "CC = %3;"
+  "if ! cc jump 2f;"
+  "%2 += -1;"
+  "CC = %2 == 0;"
+  "if ! cc jump 1b (bp);"
+  "jump 4f;"
+  "2:"
+
+  "%3 = 0;"
+  "3:"
+  "%2 += -1;"
+  "CC = %2 == 0;"
+  "if cc jump 4f;"
+  "B [%0++] = %3;"
+  "jump 3b;"
+  "4:"
+  : "+&a" (dest), "+&a" (src), "+&da" (n), "=&d" (temp)
+  :
+  : "memory", "CC");
+
+ return xdest;
+}
+
+
+extern inline __attribute__((always_inline)) int strcmp(const char *cs, const char *ct)
+{
+
+
+
+ int __res1, __res2;
+
+ __asm__ __volatile__ (
+  "1:"
+  "%2 = B[%0++] (Z);"
+  "%3 = B[%1++] (Z);"
+  "CC = %2 == %3;"
+  "if ! cc jump 2f;"
+  "CC = %2;"
+  "if cc jump 1b (bp);"
+  "jump.s 3f;"
+  "2:"
+  "%2 = %2 - %3;"
+  "3:"
+  : "+&a" (cs), "+&a" (ct), "=&d" (__res1), "=&d" (__res2)
+  :
+  : "memory", "CC");
+
+ return __res1;
+}
+
+
+extern inline __attribute__((always_inline)) int strncmp(const char *cs, const char *ct, size_t count)
+{
+
+
+
+ int __res1, __res2;
+
+ if (!count)
+  return 0;
+
+ __asm__ __volatile__ (
+  "1:"
+  "%3 = B[%0++] (Z);"
+  "%4 = B[%1++] (Z);"
+  "CC = %3 == %4;"
+  "if ! cc jump 3f;"
+  "CC = %3;"
+  "if ! cc jump 4f;"
+  "%2 += -1;"
+  "CC = %2 == 0;"
+  "if ! cc jump 1b;"
+  "2:"
+  "%3 = 0;"
+  "jump.s 4f;"
+  "3:"
+  "%3 = %3 - %4;"
+  "4:"
+  : "+&a" (cs), "+&a" (ct), "+&da" (count), "=&d" (__res1), "=&d" (__res2)
+  :
+  : "memory", "CC");
+
+ return __res1;
+}
+
+
+extern void *memset(void *s, int c, size_t count);
+
+extern void *memcpy(void *d, const void *s, size_t count);
+
+extern int memcmp(const void *, const void *, __kernel_size_t);
+
+extern void *memchr(const void *s, int c, size_t n);
+
+extern void *memmove(void *dest, const void *src, size_t count);
+# 22 "include/linux/string.h" 2
+# 30 "include/linux/string.h"
+size_t strlcpy(char *, const char *, size_t);
+
+
+extern char * strcat(char *, const char *);
+
+
+extern char * strncat(char *, const char *, __kernel_size_t);
+
+
+extern size_t strlcat(char *, const char *, __kernel_size_t);
+# 48 "include/linux/string.h"
+extern int strnicmp(const char *, const char *, __kernel_size_t);
+
+
+extern 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 * __attribute__((warn_unused_result)) 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 *);
+# 98 "include/linux/string.h"
+extern void * memscan(void *,int,__kernel_size_t);
+# 107 "include/linux/string.h"
+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);
+
+
+int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
+int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
+int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __attribute__((format(printf,3,4)));
+
+
+extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
+   const void *from, size_t available);
+
+
+
+
+
+
+static inline __attribute__((always_inline)) bool strstarts(const char *str, const char *prefix)
+{
+ return strncmp(str, prefix, strlen(prefix)) == 0;
+}
+# 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 int __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 int __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);
+extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
+# 143 "include/linux/bitmap.h"
+static inline __attribute__((always_inline)) void bitmap_zero(unsigned long *dst, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *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 (!(__builtin_constant_p(nbits) && (nbits) <= 32)) {
+  int len = (nlongs - 1) * sizeof(unsigned long);
+  memset(dst, 0xff, len);
+ }
+ dst[nlongs - 1] = ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
+}
+
+static inline __attribute__((always_inline)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
+   int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *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)) int bitmap_and(unsigned long *dst, const unsigned long *src1,
+   const unsigned long *src2, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return (*dst = *src1 & *src2) != 0;
+ return __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 ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *dst = *src1 | *src2;
+ else
+  __bitmap_or(dst, src1, src2, nbits);
+}
+
+static inline __attribute__((always_inline)) void bitmap_xor(unsigned long *dst, const unsigned long *src1,
+   const unsigned long *src2, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *dst = *src1 ^ *src2;
+ else
+  __bitmap_xor(dst, src1, src2, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
+   const unsigned long *src2, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return (*dst = *src1 & ~(*src2)) != 0;
+ return __bitmap_andnot(dst, src1, src2, nbits);
+}
+
+static inline __attribute__((always_inline)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
+   int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *dst = ~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
+ else
+  __bitmap_complement(dst, src, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_equal(const unsigned long *src1,
+   const unsigned long *src2, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return ! ((*src1 ^ *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
+ else
+  return __bitmap_equal(src1, src2, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_intersects(const unsigned long *src1,
+   const unsigned long *src2, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return ((*src1 & *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL )) != 0;
+ else
+  return __bitmap_intersects(src1, src2, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_subset(const unsigned long *src1,
+   const unsigned long *src2, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return ! ((*src1 & ~(*src2)) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
+ else
+  return __bitmap_subset(src1, src2, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_empty(const unsigned long *src, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return ! (*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
+ else
+  return __bitmap_empty(src, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_full(const unsigned long *src, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return ! (~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
+ else
+  return __bitmap_full(src, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_weight(const unsigned long *src, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  return hweight_long(*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
+ return __bitmap_weight(src, nbits);
+}
+
+static inline __attribute__((always_inline)) void bitmap_shift_right(unsigned long *dst,
+   const unsigned long *src, int n, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *dst = *src >> n;
+ else
+  __bitmap_shift_right(dst, src, n, nbits);
+}
+
+static inline __attribute__((always_inline)) void bitmap_shift_left(unsigned long *dst,
+   const unsigned long *src, int n, int nbits)
+{
+ if ((__builtin_constant_p(nbits) && (nbits) <= 32))
+  *dst = (*src << n) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
+ else
+  __bitmap_shift_left(dst, src, n, nbits);
+}
+
+static inline __attribute__((always_inline)) int bitmap_parse(const char *buf, unsigned int buflen,
+   unsigned long *maskp, int nmaskbits)
+{
+ return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
+}
+# 96 "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_next_bit((srcp->bits), ((1 << 0)), 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; });
+}
+# 261 "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_next_zero_bit((maskp->bits), ((1 << 0)), 0)); __min1 < __min2 ? __min1: __min2; });
+
+}
+# 295 "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);
+}
+# 369 "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];
+# 432 "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;
+}
+# 495 "include/linux/nodemask.h"
+struct nodemask_scratch {
+ nodemask_t mask1;
+ nodemask_t mask2;
+};
+# 17 "include/linux/mmzone.h" 2
+# 1 "include/linux/pageblock-flags.h" 1
+# 29 "include/linux/pageblock-flags.h"
+enum pageblock_bits {
+ PB_migrate,
+ PB_migrate_end = PB_migrate + 3 - 1,
+
+ NR_PAGEBLOCK_BITS
+};
+# 60 "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
+# 50 "include/linux/mmzone.h"
+extern int page_group_by_mobility_disabled;
+
+static inline __attribute__((always_inline)) int get_pageblock_migratetype(struct page *page)
+{
+ 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;
+# 79 "include/linux/mmzone.h"
+enum zone_stat_item {
+
+ NR_FREE_PAGES,
+ NR_LRU_BASE,
+ NR_INACTIVE_ANON = NR_LRU_BASE,
+ NR_ACTIVE_ANON,
+ NR_INACTIVE_FILE,
+ NR_ACTIVE_FILE,
+ NR_UNEVICTABLE,
+ NR_MLOCK,
+ NR_ANON_PAGES,
+ NR_FILE_MAPPED,
+
+ NR_FILE_PAGES,
+ NR_FILE_DIRTY,
+ NR_WRITEBACK,
+ NR_SLAB_RECLAIMABLE,
+ NR_SLAB_UNRECLAIMABLE,
+ NR_PAGETABLE,
+ NR_KERNEL_STACK,
+
+ NR_UNSTABLE_NFS,
+ NR_BOUNCE,
+ NR_VMSCAN_WRITE,
+ NR_WRITEBACK_TEMP,
+ NR_ISOLATED_ANON,
+ NR_ISOLATED_FILE,
+ NR_SHMEM,
+# 115 "include/linux/mmzone.h"
+ NR_VM_ZONE_STAT_ITEMS };
+# 130 "include/linux/mmzone.h"
+enum lru_list {
+ LRU_INACTIVE_ANON = 0,
+ LRU_ACTIVE_ANON = 0 + 1,
+ LRU_INACTIVE_FILE = 0 + 2,
+ LRU_ACTIVE_FILE = 0 + 2 + 1,
+ LRU_UNEVICTABLE,
+ NR_LRU_LISTS
+};
+
+
+
+
+
+static inline __attribute__((always_inline)) int is_file_lru(enum lru_list l)
+{
+ return (l == LRU_INACTIVE_FILE || l == LRU_ACTIVE_FILE);
+}
+
+static inline __attribute__((always_inline)) int is_active_lru(enum lru_list l)
+{
+ return (l == LRU_ACTIVE_ANON || l == LRU_ACTIVE_FILE);
+}
+
+static inline __attribute__((always_inline)) int is_unevictable_lru(enum lru_list l)
+{
+ return (l == LRU_UNEVICTABLE);
+}
+
+enum zone_watermarks {
+ WMARK_MIN,
+ WMARK_LOW,
+ WMARK_HIGH,
+ NR_WMARK
+};
+
+
+
+
+
+struct per_cpu_pages {
+ int count;
+ int high;
+ int batch;
+
+
+ struct list_head lists[3];
+};
+
+struct per_cpu_pageset {
+ struct per_cpu_pages pcp;
+
+
+
+
+
+
+
+} ;
+# 197 "include/linux/mmzone.h"
+enum zone_type {
+# 217 "include/linux/mmzone.h"
+ ZONE_DMA,
+# 232 "include/linux/mmzone.h"
+ ZONE_NORMAL,
+# 244 "include/linux/mmzone.h"
+ ZONE_MOVABLE,
+ __MAX_NR_ZONES
+};
+# 268 "include/linux/mmzone.h"
+struct zone_reclaim_stat {
+# 277 "include/linux/mmzone.h"
+ unsigned long recent_rotated[2];
+ unsigned long recent_scanned[2];
+
+
+
+
+ unsigned long nr_saved_scan[NR_LRU_LISTS];
+};
+
+struct zone {
+
+
+
+ unsigned long watermark[NR_WMARK];
+# 300 "include/linux/mmzone.h"
+ unsigned long lowmem_reserve[3];
+# 311 "include/linux/mmzone.h"
+ struct per_cpu_pageset pageset[1];
+
+
+
+
+ spinlock_t lock;
+
+
+
+
+ struct free_area free_area[14];
+
+
+
+
+
+
+ unsigned long *pageblock_flags;
+
+
+
+
+
+
+ spinlock_t lru_lock;
+ struct zone_lru {
+  struct list_head list;
+ } lru[NR_LRU_LISTS];
+
+ struct zone_reclaim_stat reclaim_stat;
+
+ unsigned long pages_scanned;
+ unsigned long flags;
+
+
+ atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
+# 361 "include/linux/mmzone.h"
+ int prev_priority;
+
+
+
+
+
+ unsigned int inactive_ratio;
+
+
+
+# 397 "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;
+# 418 "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 test_bit(ZONE_ALL_UNRECLAIMABLE, &zone->flags);
+}
+
+static inline __attribute__((always_inline)) int zone_is_reclaim_locked(const struct zone *zone)
+{
+ return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
+}
+
+static inline __attribute__((always_inline)) int zone_is_oom_locked(const struct zone *zone)
+{
+ return test_bit(ZONE_OOM_LOCKED, &zone->flags);
+}
+# 551 "include/linux/mmzone.h"
+struct zonelist_cache;
+
+
+
+
+
+
+struct zoneref {
+ struct zone *zone;
+ int zone_idx;
+};
+# 580 "include/linux/mmzone.h"
+struct zonelist {
+ struct zonelist_cache *zlcache_ptr;
+ struct zoneref _zonerefs[((1 << 0) * 3) + 1];
+
+
+
+};
+# 598 "include/linux/mmzone.h"
+extern struct page *mem_map;
+# 612 "include/linux/mmzone.h"
+struct bootmem_data;
+typedef struct pglist_data {
+ struct zone node_zones[3];
+ struct zonelist node_zonelists[1];
+ int nr_zones;
+
+ struct page *node_mem_map;
+
+
+
+
+ struct bootmem_data *bdata;
+# 634 "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;
+# 653 "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
+# 12 "include/linux/notifier.h"
+# 1 "include/linux/errno.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/errno.h" 1
+# 1 "include/asm-generic/errno.h" 1
+
+
+
+# 1 "include/asm-generic/errno-base.h" 1
+# 5 "include/asm-generic/errno.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/errno.h" 2
+# 5 "include/linux/errno.h" 2
+# 13 "include/linux/notifier.h" 2
+# 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;
+
+ struct thread_info *owner;
+
+
+ const char *name;
+ void *magic;
+
+
+ struct lockdep_map dep_map;
+
+};
+
+
+
+
+
+struct mutex_waiter {
+ struct list_head list;
+ struct task_struct *task;
+
+ void *magic;
+
+};
+
+
+# 1 "include/linux/mutex-debug.h" 1
+# 21 "include/linux/mutex-debug.h"
+extern void mutex_destroy(struct mutex *lock);
+# 79 "include/linux/mutex.h" 2
+# 107 "include/linux/mutex.h"
+extern void __mutex_init(struct mutex *lock, const char *name,
+    struct lock_class_key *key);
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int mutex_is_locked(struct mutex *lock)
+{
+ return ((&lock->count)->counter) != 1;
+}
+
+
+
+
+
+
+extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
+extern int __attribute__((warn_unused_result)) mutex_lock_interruptible_nested(struct mutex *lock,
+     unsigned int subclass);
+extern int __attribute__((warn_unused_result)) mutex_lock_killable_nested(struct mutex *lock,
+     unsigned int subclass);
+# 151 "include/linux/mutex.h"
+extern int mutex_trylock(struct mutex *lock);
+extern void mutex_unlock(struct mutex *lock);
+extern int atomic_dec_and_mutex_lock(atomic_t *cnt, 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;
+
+ struct lockdep_map dep_map;
+
+};
+# 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);
+# 74 "include/linux/rwsem.h"
+extern void down_read_nested(struct rw_semaphore *sem, int subclass);
+extern void down_write_nested(struct rw_semaphore *sem, int subclass);
+
+
+
+
+
+
+extern void down_read_non_owner(struct rw_semaphore *sem);
+extern void up_read_non_owner(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;
+}
+# 261 "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;
+# 165 "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)
+{
+}
+# 199 "include/linux/memory_hotplug.h"
+static inline __attribute__((always_inline)) int is_mem_section_removable(unsigned long pfn,
+     unsigned long nr_pages)
+{
+ return 0;
+}
+
+
+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);
+# 654 "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) {}
+# 684 "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 zone == zone->zone_pgdat->node_zones + ZONE_DMA;
+
+
+
+}
+
+
+struct ctl_table;
+int min_free_kbytes_sysctl_handler(struct ctl_table *, int,
+     void *, size_t *, loff_t *);
+extern int sysctl_lowmem_reserve_ratio[3 -1];
+int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int,
+     void *, size_t *, loff_t *);
+int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int,
+     void *, size_t *, loff_t *);
+int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
+   void *, size_t *, loff_t *);
+int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
+   void *, size_t *, loff_t *);
+
+extern int numa_zonelist_order_handler(struct ctl_table *, int,
+   void *, size_t *, loff_t *);
+extern char numa_zonelist_order[];
+
+
+
+
+extern struct pglist_data contig_page_data;
+# 787 "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);
+# 819 "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;
+
+}
+# 852 "include/linux/mmzone.h"
+struct zoneref *next_zones_zonelist(struct zoneref *z,
+     enum zone_type highest_zoneidx,
+     nodemask_t *nodes,
+     struct zone **zone);
+# 869 "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);
+}
+# 912 "include/linux/mmzone.h"
+static inline __attribute__((always_inline)) unsigned long early_pfn_to_nid(unsigned long pfn)
+{
+ return 0;
+}
+# 1093 "include/linux/mmzone.h"
+void memory_present(int nid, unsigned long start, unsigned long end);
+unsigned long __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) node_memmap_size_bytes(int, unsigned long, unsigned long);
+# 1127 "include/linux/mmzone.h"
+static inline __attribute__((always_inline)) int memmap_valid_within(unsigned long pfn,
+     struct page *page, struct zone *zone)
+{
+ return 1;
+}
+# 5 "include/linux/gfp.h" 2
+
+
+# 1 "include/linux/topology.h" 1
+# 30 "include/linux/topology.h"
+# 1 "include/linux/cpumask.h" 1
+# 13 "include/linux/cpumask.h"
+typedef struct cpumask { unsigned long bits[(((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))]; } cpumask_t;
+# 78 "include/linux/cpumask.h"
+extern const struct cpumask *const cpu_possible_mask;
+extern const struct cpumask *const cpu_online_mask;
+extern const struct cpumask *const cpu_present_mask;
+extern const struct cpumask *const cpu_active_mask;
+# 102 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) unsigned int cpumask_check(unsigned int cpu)
+{
+
+
+
+ return cpu;
+}
+
+
+
+static inline __attribute__((always_inline)) unsigned int cpumask_first(const struct cpumask *srcp)
+{
+ return 0;
+}
+
+
+static inline __attribute__((always_inline)) unsigned int cpumask_next(int n, const struct cpumask *srcp)
+{
+ return n+1;
+}
+
+static inline __attribute__((always_inline)) unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
+{
+ return n+1;
+}
+
+static inline __attribute__((always_inline)) unsigned int cpumask_next_and(int n,
+         const struct cpumask *srcp,
+         const struct cpumask *andp)
+{
+ return n+1;
+}
+
+
+static inline __attribute__((always_inline)) unsigned int cpumask_any_but(const struct cpumask *mask,
+        unsigned int cpu)
+{
+ return 1;
+}
+# 238 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
+{
+ set_bit(cpumask_check(cpu), ((dstp)->bits));
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_clear_cpu(int cpu, struct cpumask *dstp)
+{
+ clear_bit(cpumask_check(cpu), ((dstp)->bits));
+}
+# 270 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)
+{
+ return test_and_set_bit(cpumask_check(cpu), ((cpumask)->bits));
+}
+# 282 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask)
+{
+ return test_and_clear_bit(cpumask_check(cpu), ((cpumask)->bits));
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_setall(struct cpumask *dstp)
+{
+ bitmap_fill(((dstp)->bits), 1);
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_clear(struct cpumask *dstp)
+{
+ bitmap_zero(((dstp)->bits), 1);
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int cpumask_and(struct cpumask *dstp,
+          const struct cpumask *src1p,
+          const struct cpumask *src2p)
+{
+ return bitmap_and(((dstp)->bits), ((src1p)->bits),
+           ((src2p)->bits), 1);
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,
+         const struct cpumask *src2p)
+{
+ bitmap_or(((dstp)->bits), ((src1p)->bits),
+          ((src2p)->bits), 1);
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_xor(struct cpumask *dstp,
+          const struct cpumask *src1p,
+          const struct cpumask *src2p)
+{
+ bitmap_xor(((dstp)->bits), ((src1p)->bits),
+           ((src2p)->bits), 1);
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int cpumask_andnot(struct cpumask *dstp,
+      const struct cpumask *src1p,
+      const struct cpumask *src2p)
+{
+ return bitmap_andnot(((dstp)->bits), ((src1p)->bits),
+       ((src2p)->bits), 1);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_complement(struct cpumask *dstp,
+          const struct cpumask *srcp)
+{
+ bitmap_complement(((dstp)->bits), ((srcp)->bits),
+           1);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) bool cpumask_equal(const struct cpumask *src1p,
+    const struct cpumask *src2p)
+{
+ return bitmap_equal(((src1p)->bits), ((src2p)->bits),
+       1);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) bool cpumask_intersects(const struct cpumask *src1p,
+         const struct cpumask *src2p)
+{
+ return bitmap_intersects(((src1p)->bits), ((src2p)->bits),
+            1);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int cpumask_subset(const struct cpumask *src1p,
+     const struct cpumask *src2p)
+{
+ return bitmap_subset(((src1p)->bits), ((src2p)->bits),
+        1);
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) bool cpumask_empty(const struct cpumask *srcp)
+{
+ return bitmap_empty(((srcp)->bits), 1);
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) bool cpumask_full(const struct cpumask *srcp)
+{
+ return bitmap_full(((srcp)->bits), 1);
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) unsigned int cpumask_weight(const struct cpumask *srcp)
+{
+ return bitmap_weight(((srcp)->bits), 1);
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_shift_right(struct cpumask *dstp,
+           const struct cpumask *srcp, int n)
+{
+ bitmap_shift_right(((dstp)->bits), ((srcp)->bits), n,
+            1);
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_shift_left(struct cpumask *dstp,
+          const struct cpumask *srcp, int n)
+{
+ bitmap_shift_left(((dstp)->bits), ((srcp)->bits), n,
+           1);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void cpumask_copy(struct cpumask *dstp,
+    const struct cpumask *srcp)
+{
+ bitmap_copy(((dstp)->bits), ((srcp)->bits), 1);
+}
+# 513 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int cpumask_scnprintf(char *buf, int len,
+        const struct cpumask *srcp)
+{
+ return bitmap_scnprintf(buf, len, ((srcp)->bits), 1);
+}
+# 527 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int cpumask_parse_user(const char *buf, int len,
+         struct cpumask *dstp)
+{
+ return bitmap_parse_user(buf, len, ((dstp)->bits), 1);
+}
+# 542 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int cpulist_scnprintf(char *buf, int len,
+        const struct cpumask *srcp)
+{
+ return bitmap_scnlistprintf(buf, len, ((srcp)->bits),
+        1);
+}
+# 557 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int cpulist_parse(const char *buf, struct cpumask *dstp)
+{
+ return bitmap_parselist(buf, ((dstp)->bits), 1);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) size_t cpumask_size(void)
+{
+
+
+ return (((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long))) * sizeof(long);
+}
+# 602 "include/linux/cpumask.h"
+typedef struct cpumask cpumask_var_t[1];
+
+static inline __attribute__((always_inline)) bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
+{
+ return true;
+}
+
+static inline __attribute__((always_inline)) bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,
+       int node)
+{
+ return true;
+}
+
+static inline __attribute__((always_inline)) bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
+{
+ cpumask_clear(*mask);
+ return true;
+}
+
+static inline __attribute__((always_inline)) bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,
+       int node)
+{
+ cpumask_clear(*mask);
+ return true;
+}
+
+static inline __attribute__((always_inline)) void alloc_bootmem_cpumask_var(cpumask_var_t *mask)
+{
+}
+
+static inline __attribute__((always_inline)) void free_cpumask_var(cpumask_var_t mask)
+{
+}
+
+static inline __attribute__((always_inline)) void free_bootmem_cpumask_var(cpumask_var_t mask)
+{
+}
+
+
+
+
+extern const unsigned long cpu_all_bits[(((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];
+# 654 "include/linux/cpumask.h"
+void set_cpu_possible(unsigned int cpu, bool possible);
+void set_cpu_present(unsigned int cpu, bool present);
+void set_cpu_online(unsigned int cpu, bool online);
+void set_cpu_active(unsigned int cpu, bool active);
+void init_cpu_present(const struct cpumask *src);
+void init_cpu_possible(const struct cpumask *src);
+void init_cpu_online(const struct cpumask *src);
+# 676 "include/linux/cpumask.h"
+static inline __attribute__((always_inline)) int __check_is_bitmap(const unsigned long *bitmap)
+{
+ return 1;
+}
+# 688 "include/linux/cpumask.h"
+extern const unsigned long
+ cpu_bit_bitmap[32 +1][(((1) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];
+
+static inline __attribute__((always_inline)) const struct cpumask *get_cpu_mask(unsigned int cpu)
+{
+ const unsigned long *p = cpu_bit_bitmap[1 + cpu % 32];
+ p -= cpu / 32;
+ return ((struct cpumask *)(1 ? (p) : (void *)sizeof(__check_is_bitmap(p))));
+}
+# 795 "include/linux/cpumask.h"
+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)) int __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
+     const cpumask_t *src2p, int nbits)
+{
+ return 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)) int __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
+     const cpumask_t *src2p, int nbits)
+{
+ return bitmap_andnot(dstp->bits, src1p->bits, src2p->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_weight(const cpumask_t *srcp, int nbits)
+{
+ return bitmap_weight(srcp->bits, 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);
+}
+# 31 "include/linux/topology.h" 2
+
+
+# 1 "include/linux/smp.h" 1
+# 14 "include/linux/smp.h"
+extern void cpu_idle(void);
+
+struct call_single_data {
+ struct list_head list;
+ void (*func) (void *info);
+ void *info;
+ u16 flags;
+ u16 priv;
+};
+
+
+extern unsigned int total_cpus;
+
+int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
+    int wait);
+# 116 "include/linux/smp.h"
+static inline __attribute__((always_inline)) void smp_send_stop(void) { }
+
+
+
+
+
+static inline __attribute__((always_inline)) int up_smp_call_function(void (*func)(void *), void *info)
+{
+ return 0;
+}
+# 135 "include/linux/smp.h"
+static inline __attribute__((always_inline)) void smp_send_reschedule(int cpu) { }
+
+
+
+
+static inline __attribute__((always_inline)) void init_call_single_data(void)
+{
+}
+# 174 "include/linux/smp.h"
+extern void arch_disable_smp_support(void);
+
+void smp_setup_processor_id(void);
+# 34 "include/linux/topology.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/topology.h" 1
+# 1 "include/asm-generic/topology.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/topology.h" 2
+# 35 "include/linux/topology.h" 2
+# 48 "include/linux/topology.h"
+int arch_update_cpu_topology(void);
+# 8 "include/linux/gfp.h" 2
+# 1 "include/linux/mmdebug.h" 1
+
+
+
+# 1 "include/linux/autoconf.h" 1
+# 5 "include/linux/mmdebug.h" 2
+# 9 "include/linux/gfp.h" 2
+
+struct vm_area_struct;
+# 119 "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)0x08u))) == ((( gfp_t)0x80000u)|(( gfp_t)0x08u))); if (__builtin_expect(!!(__ret_warn_on), 0)) asm volatile( "1:  .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/gfp.h"), "i"(121), "i"((1<<0)), "i"(sizeof(struct bug_entry))); __builtin_expect(!!(__ret_warn_on), 0); });
+
+ if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
+  return 0;
+
+
+ return (((gfp_flags & (( gfp_t)0x08u)) != 0) << 1) |
+  ((gfp_flags & (( gfp_t)0x80000u)) != 0);
+}
+# 214 "include/linux/gfp.h"
+static inline __attribute__((always_inline)) enum zone_type gfp_zone(gfp_t flags)
+{
+ enum zone_type z;
+ int bit = flags & ((( gfp_t)0x01u)|(( gfp_t)0x02u)|(( gfp_t)0x04u)|(( gfp_t)0x08u));
+
+ z = (( (ZONE_NORMAL << 0 * 2) | (ZONE_DMA << (( gfp_t)0x01u) * 2) | (ZONE_NORMAL << (( gfp_t)0x02u) * 2) | (ZONE_NORMAL << (( gfp_t)0x04u) * 2) | (ZONE_NORMAL << (( gfp_t)0x08u) * 2) | (ZONE_DMA << ((( gfp_t)0x08u) | (( gfp_t)0x01u)) * 2) | (ZONE_MOVABLE << ((( gfp_t)0x08u) | (( gfp_t)0x02u)) * 2) | (ZONE_NORMAL << ((( gfp_t)0x08u) | (( gfp_t)0x04u)) * 2)) >> (bit * 2)) &
+      ((1 << 2) - 1);
+
+ if (__builtin_constant_p(bit))
+  ((void)sizeof(char[1 - 2 * !!((( 1 << ((( gfp_t)0x01u) | (( gfp_t)0x02u)) | 1 << ((( gfp_t)0x01u) | (( gfp_t)0x04u)) | 1 << ((( gfp_t)0x04u) | (( gfp_t)0x02u)) | 1 << ((( gfp_t)0x01u) | (( gfp_t)0x04u) | (( gfp_t)0x02u)) | 1 << ((( gfp_t)0x08u) | (( gfp_t)0x02u) | (( gfp_t)0x01u)) | 1 << ((( gfp_t)0x08u) | (( gfp_t)0x04u) | (( gfp_t)0x01u)) | 1 << ((( gfp_t)0x08u) | (( gfp_t)0x04u) | (( gfp_t)0x02u)) | 1 << ((( gfp_t)0x08u) | (( gfp_t)0x04u) | (( gfp_t)0x01u) | (( gfp_t)0x02u))) >> bit) & 1)]));
+ else {
+
+
+
+ }
+ return z;
+}
+# 239 "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;
+}
+# 256 "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) { }
+
+
+struct page *
+__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
+         struct zonelist *zonelist, nodemask_t *nodemask);
+
+static inline __attribute__((always_inline)) struct page *
+__alloc_pages(gfp_t gfp_mask, unsigned int order,
+  struct zonelist *zonelist)
+{
+ return __alloc_pages_nodemask(gfp_mask, order, zonelist, ((void *)0));
+}
+
+static inline __attribute__((always_inline)) struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
+      unsigned int order)
+{
+
+ if (nid < 0)
+  nid = (((void)(0),0));
+
+ return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
+}
+
+static inline __attribute__((always_inline)) struct page *alloc_pages_exact_node(int nid, gfp_t gfp_mask,
+      unsigned int order)
+{
+ do { } while (0);
+
+ return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
+}
+# 314 "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);
+
+void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
+void free_pages_exact(void *virt, size_t size);
+
+
+
+
+
+
+
+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);
+
+
+
+
+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);
+
+extern gfp_t gfp_allowed_mask;
+
+static inline __attribute__((always_inline)) void set_gfp_allowed_mask(gfp_t mask)
+{
+ gfp_allowed_mask = mask;
+}
+# 23 "include/linux/kmod.h" 2
+# 32 "include/linux/kmod.h"
+extern int __request_module(bool wait, const char *name, ...) __attribute__((format(printf, 2, 3)));
+# 45 "include/linux/kmod.h"
+struct key;
+struct file;
+struct subprocess_info;
+
+
+struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
+        char **envp, gfp_t gfp_mask);
+
+
+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;
+ gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? ((( gfp_t)0x20u)) : ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u));
+
+ info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
+ 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;
+ gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? ((( gfp_t)0x20u)) : ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u));
+
+ info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
+ 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);
+
+extern int usermodehelper_disable(void);
+extern void usermodehelper_enable(void);
+# 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
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/elf.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/elf.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/user.h" 1
+# 1 "include/asm-generic/user.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/user.h" 2
+# 16 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/elf.h" 2
+# 25 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/elf.h"
+typedef unsigned long elf_greg_t;
+
+
+typedef elf_greg_t elf_gregset_t[40];
+
+typedef struct { } elf_fpregset_t;
+# 131 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/elf.h"
+struct mm_struct;
+struct elf_fdpic_params;
+struct elf32_phdr;
+extern int elf_fdpic_plat_process_phdr(struct mm_struct *, struct elf_fdpic_params *,
+                                       struct elf32_phdr *, unsigned long *, unsigned long *);
+# 8 "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;
+# 368 "include/linux/elf.h"
+typedef struct elf32_note {
+  Elf32_Word n_namesz;
+  Elf32_Word n_descsz;
+  Elf32_Word n_type;
+} Elf32_Nhdr;
+
+
+typedef struct elf64_note {
+  Elf64_Word n_namesz;
+  Elf64_Word n_descsz;
+  Elf64_Word n_type;
+} Elf64_Nhdr;
+
+
+
+
+extern Elf32_Dyn _DYNAMIC [];
+# 402 "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;
+};
+# 63 "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);
+};
+
+struct sysfs_dirent;
+
+
+
+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);
+int __attribute__((warn_unused_result)) sysfs_create_link_nowarn(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, const char *dir, const char *attr);
+void sysfs_notify_dirent(struct sysfs_dirent *sd);
+struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
+          const unsigned char *name);
+struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd);
+void sysfs_put(struct sysfs_dirent *sd);
+void sysfs_printk_last_file(void);
+int __attribute__((warn_unused_result)) sysfs_init(void);
+# 22 "include/linux/kobject.h" 2
+
+
+# 1 "include/linux/kref.h" 1
+# 20 "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
+# 34 "include/linux/kobject.h"
+extern char uevent_helper[];
+
+
+extern u64 uevent_seqnum;
+# 49 "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 list_head entry;
+ struct kobject *parent;
+ struct kset *kset;
+ struct kobj_type *ktype;
+ struct sysfs_dirent *sd;
+ struct kref kref;
+ 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;
+ unsigned int uevent_suppress:1;
+};
+
+extern int kobject_set_name(struct kobject *kobj, const char *name, ...)
+       __attribute__((format(printf, 2, 3)));
+extern int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
+      va_list vargs);
+
+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;
+# 154 "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 *mm_kobj;
+
+extern struct kobject *hypervisor_kobj;
+
+extern struct kobject *power_kobj;
+
+extern struct kobject *firmware_kobj;
+# 212 "include/linux/kobject.h"
+static inline __attribute__((always_inline)) int kobject_uevent(struct kobject *kobj,
+     enum kobject_action action)
+{ return 0; }
+static inline __attribute__((always_inline)) int kobject_uevent_env(struct kobject *kobj,
+          enum kobject_action action,
+          char *envp[])
+{ return 0; }
+
+static inline __attribute__((always_inline)) int add_uevent_var(struct kobj_uevent_env *env,
+     const char *format, ...)
+{ return 0; }
+
+static inline __attribute__((always_inline)) int kobject_action_type(const char *buf, size_t count,
+          enum kobject_action *type)
+{ return -22; }
+# 17 "include/linux/module.h" 2
+# 1 "include/linux/moduleparam.h" 1
+# 32 "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;
+ u16 perm;
+ u16 flags;
+ 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;
+};
+# 143 "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 void destroy_params(const struct kernel_param *params, unsigned num);
+# 165 "include/linux/moduleparam.h"
+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);
+# 208 "include/linux/moduleparam.h"
+extern int param_set_invbool(const char *val, struct kernel_param *kp);
+extern int param_get_invbool(char *buffer, struct kernel_param *kp);
+# 226 "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/tracepoint.h" 1
+# 18 "include/linux/tracepoint.h"
+# 1 "include/linux/rcupdate.h" 1
+# 42 "include/linux/rcupdate.h"
+# 1 "include/linux/completion.h" 1
+# 25 "include/linux/completion.h"
+struct completion {
+ unsigned int done;
+ wait_queue_head_t wait;
+};
+# 73 "include/linux/completion.h"
+static inline __attribute__((always_inline)) void init_completion(struct completion *x)
+{
+ x->done = 0;
+ do { static struct lock_class_key __key; __init_waitqueue_head((&x->wait), &__key); } while (0);
+}
+
+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 bool try_wait_for_completion(struct completion *x);
+extern bool completion_done(struct completion *x);
+
+extern void complete(struct completion *);
+extern void complete_all(struct completion *);
+# 43 "include/linux/rcupdate.h" 2
+
+
+
+
+
+
+struct rcu_head {
+ struct rcu_head *next;
+ void (*func)(struct rcu_head *head);
+};
+
+
+
+
+
+
+
+extern void synchronize_rcu_bh(void);
+extern void synchronize_sched(void);
+extern void rcu_barrier(void);
+extern void rcu_barrier_bh(void);
+extern void rcu_barrier_sched(void);
+extern void synchronize_sched_expedited(void);
+extern int sched_expedited_torture_stats(char *page);
+
+
+extern void rcu_init(void);
+extern void rcu_scheduler_starting(void);
+extern int rcu_needs_cpu(int cpu);
+extern int rcu_scheduler_active;
+
+
+# 1 "include/linux/rcutree.h" 1
+# 33 "include/linux/rcutree.h"
+struct notifier_block;
+
+extern void rcu_sched_qs(int cpu);
+extern void rcu_bh_qs(int cpu);
+extern int rcu_cpu_notify(struct notifier_block *self,
+     unsigned long action, void *hcpu);
+extern int rcu_needs_cpu(int cpu);
+extern int rcu_expedited_torture_stats(char *page);
+# 50 "include/linux/rcutree.h"
+static inline __attribute__((always_inline)) void __rcu_read_lock(void)
+{
+ do { } while (0);
+}
+
+static inline __attribute__((always_inline)) void __rcu_read_unlock(void)
+{
+ do { } while (0);
+}
+
+
+
+static inline __attribute__((always_inline)) void exit_rcu(void)
+{
+}
+
+
+
+static inline __attribute__((always_inline)) void __rcu_read_lock_bh(void)
+{
+ local_bh_disable();
+}
+static inline __attribute__((always_inline)) void __rcu_read_unlock_bh(void)
+{
+ local_bh_enable();
+}
+
+extern void call_rcu_sched(struct rcu_head *head,
+      void (*func)(struct rcu_head *rcu));
+extern void synchronize_rcu_expedited(void);
+
+static inline __attribute__((always_inline)) void synchronize_rcu_bh_expedited(void)
+{
+ synchronize_sched_expedited();
+}
+
+extern void __rcu_init(void);
+extern void rcu_check_callbacks(int cpu, int user);
+
+extern long rcu_batches_completed(void);
+extern long rcu_batches_completed_bh(void);
+extern long rcu_batches_completed_sched(void);
+
+
+void rcu_enter_nohz(void);
+void rcu_exit_nohz(void);
+# 106 "include/linux/rcutree.h"
+static inline __attribute__((always_inline)) int rcu_blocking_is_gp(void)
+{
+ return 1 == 1;
+}
+# 76 "include/linux/rcupdate.h" 2
+# 87 "include/linux/rcupdate.h"
+extern struct lockdep_map rcu_lock_map;
+# 125 "include/linux/rcupdate.h"
+static inline __attribute__((always_inline)) void rcu_read_lock(void)
+{
+ __rcu_read_lock();
+ (void)0;
+ lock_acquire(&rcu_lock_map, 0, 0, 2, 1, ((void *)0), ({ __label__ __here; __here: (unsigned long)&&__here; }));
+}
+# 147 "include/linux/rcupdate.h"
+static inline __attribute__((always_inline)) void rcu_read_unlock(void)
+{
+ lock_release(&rcu_lock_map, 1, ({ __label__ __here; __here: (unsigned long)&&__here; }));
+ (void)0;
+ __rcu_read_unlock();
+}
+# 165 "include/linux/rcupdate.h"
+static inline __attribute__((always_inline)) void rcu_read_lock_bh(void)
+{
+ __rcu_read_lock_bh();
+ (void)0;
+ lock_acquire(&rcu_lock_map, 0, 0, 2, 1, ((void *)0), ({ __label__ __here; __here: (unsigned long)&&__here; }));
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void rcu_read_unlock_bh(void)
+{
+ lock_release(&rcu_lock_map, 1, ({ __label__ __here; __here: (unsigned long)&&__here; }));
+ (void)0;
+ __rcu_read_unlock_bh();
+}
+# 193 "include/linux/rcupdate.h"
+static inline __attribute__((always_inline)) void rcu_read_lock_sched(void)
+{
+ do { } while (0);
+ (void)0;
+ lock_acquire(&rcu_lock_map, 0, 0, 2, 1, ((void *)0), ({ __label__ __here; __here: (unsigned long)&&__here; }));
+}
+
+
+static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_lock_sched_notrace(void)
+{
+ do { } while (0);
+ (void)0;
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void rcu_read_unlock_sched(void)
+{
+ lock_release(&rcu_lock_map, 1, ({ __label__ __here; __here: (unsigned long)&&__here; }));
+ (void)0;
+ do { } while (0);
+}
+
+
+static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_unlock_sched_notrace(void)
+{
+ (void)0;
+ do { } while (0);
+}
+# 266 "include/linux/rcupdate.h"
+struct rcu_synchronize {
+ struct rcu_head head;
+ struct completion completion;
+};
+
+extern void wakeme_after_rcu(struct rcu_head *head);
+# 284 "include/linux/rcupdate.h"
+extern void call_rcu(struct rcu_head *head,
+         void (*func)(struct rcu_head *head));
+# 305 "include/linux/rcupdate.h"
+extern void call_rcu_bh(struct rcu_head *head,
+   void (*func)(struct rcu_head *head));
+# 19 "include/linux/tracepoint.h" 2
+
+struct module;
+struct tracepoint;
+
+struct tracepoint {
+ const char *name;
+ int state;
+ void (*regfunc)(void);
+ void (*unregfunc)(void);
+ void **funcs;
+} __attribute__((aligned(32)));
+# 99 "include/linux/tracepoint.h"
+extern void tracepoint_update_probe_range(struct tracepoint *begin,
+ struct tracepoint *end);
+# 132 "include/linux/tracepoint.h"
+extern int tracepoint_probe_register(const char *name, void *probe);
+
+
+
+
+
+extern int tracepoint_probe_unregister(const char *name, void *probe);
+
+extern int tracepoint_probe_register_noupdate(const char *name, void *probe);
+extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe);
+extern void tracepoint_probe_update_all(void);
+
+struct tracepoint_iter {
+ struct module *module;
+ struct tracepoint *tracepoint;
+};
+
+extern void tracepoint_iter_start(struct tracepoint_iter *iter);
+extern void tracepoint_iter_next(struct tracepoint_iter *iter);
+extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
+extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
+extern int tracepoint_get_iter_range(struct tracepoint **tracepoint,
+ struct tracepoint *begin, struct tracepoint *end);
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void tracepoint_synchronize_unregister(void)
+{
+ synchronize_sched();
+}
+# 19 "include/linux/module.h" 2
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/local.h" 1
+# 1 "include/asm-generic/local.h" 1
+
+
+
+# 1 "include/linux/percpu.h" 1
+
+
+
+
+# 1 "include/linux/slab.h" 1
+# 93 "include/linux/slab.h"
+void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) kmem_cache_init(void);
+int slab_is_available(void);
+
+struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
+   unsigned long,
+   void (*)(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);
+# 136 "include/linux/slab.h"
+void * __attribute__((warn_unused_result)) __krealloc(const void *, size_t, gfp_t);
+void * __attribute__((warn_unused_result)) krealloc(const void *, size_t, gfp_t);
+void kfree(const void *);
+void kzfree(const void *);
+size_t ksize(const void *);
+# 162 "include/linux/slab.h"
+# 1 "include/linux/slub_def.h" 1
+# 11 "include/linux/slub_def.h"
+# 1 "include/linux/workqueue.h" 1
+
+
+
+
+
+
+
+# 1 "include/linux/timer.h" 1
+
+
+
+
+# 1 "include/linux/ktime.h" 1
+# 25 "include/linux/ktime.h"
+# 1 "include/linux/jiffies.h" 1
+
+
+
+
+
+
+
+# 1 "include/linux/timex.h" 1
+# 64 "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;
+};
+# 170 "include/linux/timex.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/timex.h" 1
+# 14 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/timex.h"
+typedef unsigned long long cycles_t;
+
+static inline __attribute__((always_inline)) cycles_t get_cycles(void)
+{
+ unsigned long tmp, tmp2;
+ __asm__ __volatile__("%0 = cycles; %1 = cycles2;" : "=d"(tmp), "=d"(tmp2));
+ return tmp | ((cycles_t)tmp2 << 32);
+}
+# 171 "include/linux/timex.h" 2
+# 230 "include/linux/timex.h"
+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);
+}
+# 272 "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);
+# 9 "include/linux/jiffies.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/param.h" 1
+# 10 "include/linux/jiffies.h" 2
+# 81 "include/linux/jiffies.h"
+extern u64 __attribute__((section(".data"))) jiffies_64;
+extern unsigned long volatile __attribute__((section(".data"))) jiffies;
+
+
+u64 get_jiffies_64(void);
+# 183 "include/linux/jiffies.h"
+extern unsigned long preset_lpj;
+# 296 "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);
+# 26 "include/linux/ktime.h" 2
+# 46 "include/linux/ktime.h"
+union ktime {
+ s64 tv64;
+
+ struct {
+
+
+
+ s32 nsec, sec;
+
+ } tv;
+
+};
+
+typedef union ktime ktime_t;
+# 151 "include/linux/ktime.h"
+static inline __attribute__((always_inline)) ktime_t ktime_set(const long secs, const unsigned long nsecs)
+{
+ return (ktime_t) { .tv = { .sec = secs, .nsec = nsecs } };
+}
+# 163 "include/linux/ktime.h"
+static inline __attribute__((always_inline)) ktime_t ktime_sub(const ktime_t lhs, const ktime_t rhs)
+{
+ ktime_t res;
+
+ res.tv64 = lhs.tv64 - rhs.tv64;
+ if (res.tv.nsec < 0)
+  res.tv.nsec += 1000000000L;
+
+ return res;
+}
+# 181 "include/linux/ktime.h"
+static inline __attribute__((always_inline)) ktime_t ktime_add(const ktime_t add1, const ktime_t add2)
+{
+ ktime_t res;
+
+ res.tv64 = add1.tv64 + add2.tv64;
+# 194 "include/linux/ktime.h"
+ if (res.tv.nsec >= 1000000000L)
+  res.tv64 += (u32)-1000000000L;
+
+ return res;
+}
+# 207 "include/linux/ktime.h"
+extern ktime_t ktime_add_ns(const ktime_t kt, u64 nsec);
+# 216 "include/linux/ktime.h"
+extern ktime_t ktime_sub_ns(const ktime_t kt, u64 nsec);
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) ktime_t timespec_to_ktime(const struct timespec ts)
+{
+ return (ktime_t) { .tv = { .sec = (s32)ts.tv_sec,
+          .nsec = (s32)ts.tv_nsec } };
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) ktime_t timeval_to_ktime(const struct timeval tv)
+{
+ return (ktime_t) { .tv = { .sec = (s32)tv.tv_sec,
+       .nsec = (s32)tv.tv_usec * 1000 } };
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) struct timespec ktime_to_timespec(const ktime_t kt)
+{
+ return (struct timespec) { .tv_sec = (time_t) kt.tv.sec,
+       .tv_nsec = (long) kt.tv.nsec };
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) struct timeval ktime_to_timeval(const ktime_t kt)
+{
+ return (struct timeval) {
+  .tv_sec = (time_t) kt.tv.sec,
+  .tv_usec = (suseconds_t) (kt.tv.nsec / 1000L) };
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) s64 ktime_to_ns(const ktime_t kt)
+{
+ return (s64) kt.tv.sec * 1000000000L + kt.tv.nsec;
+}
+# 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 = ktime_to_timeval(kt);
+ 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_sub(later, earlier));
+}
+
+static inline __attribute__((always_inline)) ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
+{
+ return ktime_add_ns(kt, usec * 1000);
+}
+
+static inline __attribute__((always_inline)) ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
+{
+ return ktime_sub_ns(kt, 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_add_ns(ktime_zero, 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);
+};
+
+
+extern void debug_object_init (void *addr, struct debug_obj_descr *descr);
+extern void
+debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr);
+extern void debug_object_activate (void *addr, struct debug_obj_descr *descr);
+extern void debug_object_deactivate(void *addr, struct debug_obj_descr *descr);
+extern void debug_object_destroy (void *addr, struct debug_obj_descr *descr);
+extern void debug_object_free (void *addr, struct debug_obj_descr *descr);
+
+extern void debug_objects_early_init(void);
+extern void debug_objects_mem_init(void);
+# 86 "include/linux/debugobjects.h"
+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;
+
+ void *start_site;
+ char start_comm[16];
+ int start_pid;
+
+
+ struct lockdep_map lockdep_map;
+
+};
+
+extern struct tvec_base boot_tvec_bases;
+# 59 "include/linux/timer.h"
+void init_timer_key(struct timer_list *timer,
+      const char *name,
+      struct lock_class_key *key);
+void init_timer_deferrable_key(struct timer_list *timer,
+          const char *name,
+          struct lock_class_key *key);
+# 111 "include/linux/timer.h"
+extern void init_timer_on_stack_key(struct timer_list *timer,
+        const char *name,
+        struct lock_class_key *key);
+extern void destroy_timer_on_stack(struct timer_list *timer);
+# 125 "include/linux/timer.h"
+static inline __attribute__((always_inline)) void setup_timer_key(struct timer_list * timer,
+    const char *name,
+    struct lock_class_key *key,
+    void (*function)(unsigned long),
+    unsigned long data)
+{
+ timer->function = function;
+ timer->data = data;
+ init_timer_key(timer, name, key);
+}
+
+static inline __attribute__((always_inline)) void setup_timer_on_stack_key(struct timer_list *timer,
+     const char *name,
+     struct lock_class_key *key,
+     void (*function)(unsigned long),
+     unsigned long data)
+{
+ timer->function = function;
+ timer->data = data;
+ init_timer_on_stack_key(timer, name, key);
+}
+# 157 "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_pending(struct timer_list *timer, unsigned long expires);
+extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);
+# 181 "include/linux/timer.h"
+extern unsigned long get_next_timer_interrupt(unsigned long now);
+
+
+
+
+
+
+extern int timer_stats_active;
+
+
+
+extern void init_timer_stats(void);
+
+extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
+         void *timerf, char *comm,
+         unsigned int timer_flag);
+
+extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
+            void *addr);
+
+static inline __attribute__((always_inline)) void timer_stats_timer_set_start_info(struct timer_list *timer)
+{
+ if (__builtin_expect(!!(!timer_stats_active), 1))
+  return;
+ __timer_stats_timer_set_start_info(timer, __builtin_return_address(0));
+}
+
+static inline __attribute__((always_inline)) void timer_stats_timer_clear_start_info(struct timer_list *timer)
+{
+ timer->start_site = ((void *)0);
+}
+# 226 "include/linux/timer.h"
+extern void add_timer(struct timer_list *timer);
+# 238 "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);
+
+unsigned long __round_jiffies_up(unsigned long j, int cpu);
+unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);
+unsigned long round_jiffies_up(unsigned long j);
+unsigned long round_jiffies_up_relative(unsigned long j);
+# 9 "include/linux/workqueue.h" 2
+
+
+
+
+
+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 lockdep_map lockdep_map;
+
+};
+
+
+
+struct delayed_work {
+ struct work_struct work;
+ struct timer_list timer;
+};
+
+static inline __attribute__((always_inline)) struct delayed_work *to_delayed_work(struct work_struct *work)
+{
+ return ({ const typeof( ((struct delayed_work *)0)->work ) *__mptr = (work); (struct delayed_work *)( (char *)__mptr - __builtin_offsetof(struct delayed_work,work) );});
+}
+
+struct execute_work {
+ struct work_struct work;
+};
+# 167 "include/linux/workqueue.h"
+extern struct workqueue_struct *
+__create_workqueue_key(const char *name, int singlethread,
+         int freezeable, int rt, struct lock_class_key *key,
+         const char *lock_name);
+# 198 "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_work_on(int cpu, 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 void flush_delayed_work(struct delayed_work *work);
+
+extern int schedule_work(struct work_struct *work);
+extern int schedule_work_on(int cpu, 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 flush_work(struct work_struct *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;
+}
+
+
+
+
+
+
+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);
+}
+
+
+static inline __attribute__((always_inline)) long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
+{
+ return fn(arg);
+}
+# 12 "include/linux/slub_def.h" 2
+
+# 1 "include/linux/kmemtrace.h" 1
+# 12 "include/linux/kmemtrace.h"
+# 1 "include/trace/events/kmem.h" 1
+
+
+
+
+
+
+
+# 1 "include/linux/tracepoint.h" 1
+# 9 "include/trace/events/kmem.h" 2
+# 47 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_kmalloc; static inline __attribute__((always_inline)) void trace_kmalloc(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags) { if (__builtin_expect(!!(__tracepoint_kmalloc.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_kmalloc)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_kmalloc)->funcs) *)&((&__tracepoint_kmalloc)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags))(*it_func))(call_site, ptr, bytes_req, bytes_alloc, gfp_flags); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_kmalloc(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags)) { return tracepoint_probe_register("kmalloc", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_kmalloc(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags)) { return tracepoint_probe_unregister("kmalloc", (void *)probe); };
+# 81 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_kmem_cache_alloc; static inline __attribute__((always_inline)) void trace_kmem_cache_alloc(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags) { if (__builtin_expect(!!(__tracepoint_kmem_cache_alloc.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_kmem_cache_alloc)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_kmem_cache_alloc)->funcs) *)&((&__tracepoint_kmem_cache_alloc)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags))(*it_func))(call_site, ptr, bytes_req, bytes_alloc, gfp_flags); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_kmem_cache_alloc(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags)) { return tracepoint_probe_register("kmem_cache_alloc", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_kmem_cache_alloc(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags)) { return tracepoint_probe_unregister("kmem_cache_alloc", (void *)probe); };
+# 115 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_kmalloc_node; static inline __attribute__((always_inline)) void trace_kmalloc_node(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node) { if (__builtin_expect(!!(__tracepoint_kmalloc_node.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_kmalloc_node)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_kmalloc_node)->funcs) *)&((&__tracepoint_kmalloc_node)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node))(*it_func))(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_kmalloc_node(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node)) { return tracepoint_probe_register("kmalloc_node", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_kmalloc_node(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node)) { return tracepoint_probe_unregister("kmalloc_node", (void *)probe); };
+# 153 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_kmem_cache_alloc_node; static inline __attribute__((always_inline)) void trace_kmem_cache_alloc_node(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node) { if (__builtin_expect(!!(__tracepoint_kmem_cache_alloc_node.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_kmem_cache_alloc_node)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_kmem_cache_alloc_node)->funcs) *)&((&__tracepoint_kmem_cache_alloc_node)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node))(*it_func))(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_kmem_cache_alloc_node(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node)) { return tracepoint_probe_register("kmem_cache_alloc_node", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_kmem_cache_alloc_node(void (*probe)(unsigned long call_site, const void *ptr, size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags, int node)) { return tracepoint_probe_unregister("kmem_cache_alloc_node", (void *)probe); };
+# 191 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_kfree; static inline __attribute__((always_inline)) void trace_kfree(unsigned long call_site, const void *ptr) { if (__builtin_expect(!!(__tracepoint_kfree.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_kfree)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_kfree)->funcs) *)&((&__tracepoint_kfree)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(unsigned long call_site, const void *ptr))(*it_func))(call_site, ptr); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_kfree(void (*probe)(unsigned long call_site, const void *ptr)) { return tracepoint_probe_register("kfree", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_kfree(void (*probe)(unsigned long call_site, const void *ptr)) { return tracepoint_probe_unregister("kfree", (void *)probe); };
+# 210 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_kmem_cache_free; static inline __attribute__((always_inline)) void trace_kmem_cache_free(unsigned long call_site, const void *ptr) { if (__builtin_expect(!!(__tracepoint_kmem_cache_free.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_kmem_cache_free)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_kmem_cache_free)->funcs) *)&((&__tracepoint_kmem_cache_free)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(unsigned long call_site, const void *ptr))(*it_func))(call_site, ptr); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_kmem_cache_free(void (*probe)(unsigned long call_site, const void *ptr)) { return tracepoint_probe_register("kmem_cache_free", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_kmem_cache_free(void (*probe)(unsigned long call_site, const void *ptr)) { return tracepoint_probe_unregister("kmem_cache_free", (void *)probe); };
+# 229 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_mm_page_free_direct; static inline __attribute__((always_inline)) void trace_mm_page_free_direct(struct page *page, unsigned int order) { if (__builtin_expect(!!(__tracepoint_mm_page_free_direct.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_mm_page_free_direct)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_mm_page_free_direct)->funcs) *)&((&__tracepoint_mm_page_free_direct)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct page *page, unsigned int order))(*it_func))(page, order); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_mm_page_free_direct(void (*probe)(struct page *page, unsigned int order)) { return tracepoint_probe_register("mm_page_free_direct", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_mm_page_free_direct(void (*probe)(struct page *page, unsigned int order)) { return tracepoint_probe_unregister("mm_page_free_direct", (void *)probe); };
+# 251 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_mm_pagevec_free; static inline __attribute__((always_inline)) void trace_mm_pagevec_free(struct page *page, int cold) { if (__builtin_expect(!!(__tracepoint_mm_pagevec_free.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_mm_pagevec_free)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_mm_pagevec_free)->funcs) *)&((&__tracepoint_mm_pagevec_free)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct page *page, int cold))(*it_func))(page, cold); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_mm_pagevec_free(void (*probe)(struct page *page, int cold)) { return tracepoint_probe_register("mm_pagevec_free", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_mm_pagevec_free(void (*probe)(struct page *page, int cold)) { return tracepoint_probe_unregister("mm_pagevec_free", (void *)probe); };
+# 273 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_mm_page_alloc; static inline __attribute__((always_inline)) void trace_mm_page_alloc(struct page *page, unsigned int order, gfp_t gfp_flags, int migratetype) { if (__builtin_expect(!!(__tracepoint_mm_page_alloc.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_mm_page_alloc)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_mm_page_alloc)->funcs) *)&((&__tracepoint_mm_page_alloc)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct page *page, unsigned int order, gfp_t gfp_flags, int migratetype))(*it_func))(page, order, gfp_flags, migratetype); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_mm_page_alloc(void (*probe)(struct page *page, unsigned int order, gfp_t gfp_flags, int migratetype)) { return tracepoint_probe_register("mm_page_alloc", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_mm_page_alloc(void (*probe)(struct page *page, unsigned int order, gfp_t gfp_flags, int migratetype)) { return tracepoint_probe_unregister("mm_page_alloc", (void *)probe); };
+# 302 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_mm_page_alloc_zone_locked; static inline __attribute__((always_inline)) void trace_mm_page_alloc_zone_locked(struct page *page, unsigned int order, int migratetype) { if (__builtin_expect(!!(__tracepoint_mm_page_alloc_zone_locked.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_mm_page_alloc_zone_locked)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_mm_page_alloc_zone_locked)->funcs) *)&((&__tracepoint_mm_page_alloc_zone_locked)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct page *page, unsigned int order, int migratetype))(*it_func))(page, order, migratetype); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_mm_page_alloc_zone_locked(void (*probe)(struct page *page, unsigned int order, int migratetype)) { return tracepoint_probe_register("mm_page_alloc_zone_locked", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_mm_page_alloc_zone_locked(void (*probe)(struct page *page, unsigned int order, int migratetype)) { return tracepoint_probe_unregister("mm_page_alloc_zone_locked", (void *)probe); };
+# 328 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_mm_page_pcpu_drain; static inline __attribute__((always_inline)) void trace_mm_page_pcpu_drain(struct page *page, int order, int migratetype) { if (__builtin_expect(!!(__tracepoint_mm_page_pcpu_drain.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_mm_page_pcpu_drain)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_mm_page_pcpu_drain)->funcs) *)&((&__tracepoint_mm_page_pcpu_drain)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct page *page, int order, int migratetype))(*it_func))(page, order, migratetype); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_mm_page_pcpu_drain(void (*probe)(struct page *page, int order, int migratetype)) { return tracepoint_probe_register("mm_page_pcpu_drain", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_mm_page_pcpu_drain(void (*probe)(struct page *page, int order, int migratetype)) { return tracepoint_probe_unregister("mm_page_pcpu_drain", (void *)probe); };
+# 353 "include/trace/events/kmem.h"
+extern struct tracepoint __tracepoint_mm_page_alloc_extfrag; static inline __attribute__((always_inline)) void trace_mm_page_alloc_extfrag(struct page *page, int alloc_order, int fallback_order, int alloc_migratetype, int fallback_migratetype) { if (__builtin_expect(!!(__tracepoint_mm_page_alloc_extfrag.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_mm_page_alloc_extfrag)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_mm_page_alloc_extfrag)->funcs) *)&((&__tracepoint_mm_page_alloc_extfrag)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct page *page, int alloc_order, int fallback_order, int alloc_migratetype, int fallback_migratetype))(*it_func))(page, alloc_order, fallback_order, alloc_migratetype, fallback_migratetype); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_mm_page_alloc_extfrag(void (*probe)(struct page *page, int alloc_order, int fallback_order, int alloc_migratetype, int fallback_migratetype)) { return tracepoint_probe_register("mm_page_alloc_extfrag", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_mm_page_alloc_extfrag(void (*probe)(struct page *page, int alloc_order, int fallback_order, int alloc_migratetype, int fallback_migratetype)) { return tracepoint_probe_unregister("mm_page_alloc_extfrag", (void *)probe); };
+# 394 "include/trace/events/kmem.h"
+# 1 "include/trace/define_trace.h" 1
+# 394 "include/trace/events/kmem.h" 2
+# 13 "include/linux/kmemtrace.h" 2
+
+
+
+
+static inline __attribute__((always_inline)) void kmemtrace_init(void)
+{
+}
+# 14 "include/linux/slub_def.h" 2
+# 1 "include/linux/kmemleak.h" 1
+# 60 "include/linux/kmemleak.h"
+static inline __attribute__((always_inline)) void kmemleak_init(void)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_alloc(const void *ptr, size_t size, int min_count,
+      gfp_t gfp)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_alloc_recursive(const void *ptr, size_t size,
+         int min_count, unsigned long flags,
+         gfp_t gfp)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_free(const void *ptr)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_free_part(const void *ptr, size_t size)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_free_recursive(const void *ptr, unsigned long flags)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_not_leak(const void *ptr)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_ignore(const void *ptr)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_scan_area(const void *ptr, unsigned long offset,
+          size_t length, gfp_t gfp)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_erase(void **ptr)
+{
+}
+static inline __attribute__((always_inline)) void kmemleak_no_scan(const void *ptr)
+{
+}
+# 15 "include/linux/slub_def.h" 2
+
+enum stat_item {
+ ALLOC_FASTPATH,
+ ALLOC_SLOWPATH,
+ FREE_FASTPATH,
+ FREE_SLOWPATH,
+ FREE_FROZEN,
+ FREE_ADD_PARTIAL,
+ FREE_REMOVE_PARTIAL,
+ ALLOC_FROM_PARTIAL,
+ ALLOC_SLAB,
+ ALLOC_REFILL,
+ FREE_SLAB,
+ CPUSLAB_FLUSH,
+ DEACTIVATE_FULL,
+ DEACTIVATE_EMPTY,
+ DEACTIVATE_TO_HEAD,
+ DEACTIVATE_TO_TAIL,
+ DEACTIVATE_REMOTE_FREES,
+ ORDER_FALLBACK,
+ NR_SLUB_STAT_ITEMS };
+
+struct kmem_cache_cpu {
+ void **freelist;
+ struct page *page;
+ int node;
+ unsigned int offset;
+ unsigned int objsize;
+
+ unsigned stat[NR_SLUB_STAT_ITEMS];
+
+};
+
+struct kmem_cache_node {
+ spinlock_t list_lock;
+ unsigned long nr_partial;
+ struct list_head partial;
+
+ atomic_long_t nr_slabs;
+ atomic_long_t total_objects;
+ struct list_head full;
+
+};
+
+
+
+
+
+
+struct kmem_cache_order_objects {
+ unsigned long x;
+};
+
+
+
+
+struct kmem_cache {
+
+ unsigned long flags;
+ int size;
+ int objsize;
+ int offset;
+ struct kmem_cache_order_objects oo;
+
+
+
+
+
+ struct kmem_cache_node local_node;
+
+
+ struct kmem_cache_order_objects max;
+ struct kmem_cache_order_objects min;
+ gfp_t allocflags;
+ int refcount;
+ void (*ctor)(void *);
+ int inuse;
+ int align;
+ unsigned long min_partial;
+ const char *name;
+ struct list_head list;
+
+ struct kobject kobj;
+# 110 "include/linux/slub_def.h"
+ struct kmem_cache_cpu cpu_slab;
+
+};
+# 142 "include/linux/slub_def.h"
+extern struct kmem_cache kmalloc_caches[(12 + 2)];
+
+
+
+
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) int kmalloc_index(size_t size)
+{
+ if (!size)
+  return 0;
+
+ if (size <= 8)
+  return ( __builtin_constant_p(8) ? ( (8) < 1 ? ____ilog2_NaN() : (8) & (1ULL << 63) ? 63 : (8) & (1ULL << 62) ? 62 : (8) & (1ULL << 61) ? 61 : (8) & (1ULL << 60) ? 60 : (8) & (1ULL << 59) ? 59 : (8) & (1ULL << 58) ? 58 : (8) & (1ULL << 57) ? 57 : (8) & (1ULL << 56) ? 56 : (8) & (1ULL << 55) ? 55 : (8) & (1ULL << 54) ? 54 : (8) & (1ULL << 53) ? 53 : (8) & (1ULL << 52) ? 52 : (8) & (1ULL << 51) ? 51 : (8) & (1ULL << 50) ? 50 : (8) & (1ULL << 49) ? 49 : (8) & (1ULL << 48) ? 48 : (8) & (1ULL << 47) ? 47 : (8) & (1ULL << 46) ? 46 : (8) & (1ULL << 45) ? 45 : (8) & (1ULL << 44) ? 44 : (8) & (1ULL << 43) ? 43 : (8) & (1ULL << 42) ? 42 : (8) & (1ULL << 41) ? 41 : (8) & (1ULL << 40) ? 40 : (8) & (1ULL << 39) ? 39 : (8) & (1ULL << 38) ? 38 : (8) & (1ULL << 37) ? 37 : (8) & (1ULL << 36) ? 36 : (8) & (1ULL << 35) ? 35 : (8) & (1ULL << 34) ? 34 : (8) & (1ULL << 33) ? 33 : (8) & (1ULL << 32) ? 32 : (8) & (1ULL << 31) ? 31 : (8) & (1ULL << 30) ? 30 : (8) & (1ULL << 29) ? 29 : (8) & (1ULL << 28) ? 28 : (8) & (1ULL << 27) ? 27 : (8) & (1ULL << 26) ? 26 : (8) & (1ULL << 25) ? 25 : (8) & (1ULL << 24) ? 24 : (8) & (1ULL << 23) ? 23 : (8) & (1ULL << 22) ? 22 : (8) & (1ULL << 21) ? 21 : (8) & (1ULL << 20) ? 20 : (8) & (1ULL << 19) ? 19 : (8) & (1ULL << 18) ? 18 : (8) & (1ULL << 17) ? 17 : (8) & (1ULL << 16) ? 16 : (8) & (1ULL << 15) ? 15 : (8) & (1ULL << 14) ? 14 : (8) & (1ULL << 13) ? 13 : (8) & (1ULL << 12) ? 12 : (8) & (1ULL << 11) ? 11 : (8) & (1ULL << 10) ? 10 : (8) & (1ULL << 9) ? 9 : (8) & (1ULL << 8) ? 8 : (8) & (1ULL << 7) ? 7 : (8) & (1ULL << 6) ? 6 : (8) & (1ULL << 5) ? 5 : (8) & (1ULL << 4) ? 4 : (8) & (1ULL << 3) ? 3 : (8) & (1ULL << 2) ? 2 : (8) & (1ULL << 1) ? 1 : (8) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof(8) <= 4) ? __ilog2_u32(8) : __ilog2_u64(8) );
+
+ if (8 <= 32 && size > 64 && size <= 96)
+  return 1;
+ if (8 <= 64 && size > 128 && size <= 192)
+  return 2;
+ if (size <= 8) return 3;
+ if (size <= 16) return 4;
+ if (size <= 32) return 5;
+ if (size <= 64) return 6;
+ if (size <= 128) return 7;
+ if (size <= 256) return 8;
+ if (size <= 512) return 9;
+ if (size <= 1024) return 10;
+ if (size <= 2 * 1024) return 11;
+ if (size <= 4 * 1024) return 12;
+
+
+
+
+ if (size <= 8 * 1024) return 13;
+ if (size <= 16 * 1024) return 14;
+ if (size <= 32 * 1024) return 15;
+ if (size <= 64 * 1024) return 16;
+ if (size <= 128 * 1024) return 17;
+ if (size <= 256 * 1024) return 18;
+ if (size <= 512 * 1024) return 19;
+ if (size <= 1024 * 1024) return 20;
+ if (size <= 2 * 1024 * 1024) return 21;
+ return -1;
+# 192 "include/linux/slub_def.h"
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) struct kmem_cache *kmalloc_slab(size_t size)
+{
+ int index = kmalloc_index(size);
+
+ if (index == 0)
+  return ((void *)0);
+
+ return &kmalloc_caches[index];
+}
+# 217 "include/linux/slub_def.h"
+void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
+void *__kmalloc(size_t size, gfp_t flags);
+
+
+
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) void *
+kmem_cache_alloc_notrace(struct kmem_cache *s, gfp_t gfpflags)
+{
+ return kmem_cache_alloc(s, gfpflags);
+}
+
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) void *kmalloc_large(size_t size, gfp_t flags)
+{
+ unsigned int order = get_order(size);
+ void *ret = (void *) __get_free_pages(flags | (( gfp_t)0x4000u), order);
+
+ kmemleak_alloc(ret, size, 1, flags);
+ trace_kmalloc(({ __label__ __here; __here: (unsigned long)&&__here; }), ret, size, (1UL << 12) << order, flags);
+
+ return ret;
+}
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) void *kmalloc(size_t size, gfp_t flags)
+{
+ void *ret;
+
+ if (__builtin_constant_p(size)) {
+  if (size > (2 * (1UL << 12)))
+   return kmalloc_large(size, flags);
+
+  if (!(flags & (( gfp_t)0x01u))) {
+   struct kmem_cache *s = kmalloc_slab(size);
+
+   if (!s)
+    return ((void *)16);
+
+   ret = kmem_cache_alloc_notrace(s, flags);
+
+   trace_kmalloc(({ __label__ __here; __here: (unsigned long)&&__here; }), ret, size, s->size, flags);
+
+   return ret;
+  }
+ }
+ return __kmalloc(size, flags);
+}
+# 163 "include/linux/slab.h" 2
+# 220 "include/linux/slab.h"
+static inline __attribute__((always_inline)) void *kcalloc(size_t n, size_t size, gfp_t flags)
+{
+ if (size != 0 && n > (~0UL) / size)
+  return ((void *)0);
+ return __kmalloc(n * size, flags | (( gfp_t)0x8000u));
+}
+# 238 "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);
+}
+# 266 "include/linux/slab.h"
+extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
+# 303 "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));
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void *kzalloc_node(size_t size, gfp_t flags, int node)
+{
+ return kmalloc_node(size, flags | (( gfp_t)0x8000u), node);
+}
+
+void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) kmem_cache_init_late(void);
+# 6 "include/linux/percpu.h" 2
+
+
+# 1 "include/linux/pfn.h" 1
+# 9 "include/linux/percpu.h" 2
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/percpu.h" 1
+# 1 "include/asm-generic/percpu.h" 1
+
+
+
+
+
+# 1 "include/linux/percpu-defs.h" 1
+# 7 "include/asm-generic/percpu.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/percpu.h" 2
+# 11 "include/linux/percpu.h" 2
+# 166 "include/linux/percpu.h"
+static inline __attribute__((always_inline)) void *__alloc_percpu(size_t size, size_t align)
+{
+
+
+
+
+
+ ({ static int __warned; int __ret_warn_once = !!(align > (1 << 5)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) asm volatile( "1:     .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/percpu.h"), "i"(173), "i"((1<<0)), "i"(sizeof(struct bug_entry))); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = 1; __builtin_expect(!!(__ret_warn_once), 0); });
+ return kzalloc(size, ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
+}
+
+static inline __attribute__((always_inline)) void free_percpu(void *p)
+{
+ kfree(p);
+}
+
+static inline __attribute__((always_inline)) void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) setup_per_cpu_areas(void) { }
+
+static inline __attribute__((always_inline)) void *pcpu_lpage_remapped(void *kaddr)
+{
+ return ((void *)0);
+}
+# 5 "include/asm-generic/local.h" 2
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 7 "include/asm-generic/local.h" 2
+# 21 "include/asm-generic/local.h"
+typedef struct
+{
+ atomic_long_t a;
+} local_t;
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/local.h" 2
+# 21 "include/linux/module.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/module.h" 1
+# 16 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/module.h"
+struct mod_arch_specific {
+ Elf32_Shdr *text_l1;
+ Elf32_Shdr *data_a_l1;
+ Elf32_Shdr *bss_a_l1;
+ Elf32_Shdr *data_b_l1;
+ Elf32_Shdr *bss_b_l1;
+ Elf32_Shdr *text_l2;
+ Elf32_Shdr *data_l2;
+ Elf32_Shdr *bss_l2;
+};
+# 22 "include/linux/module.h" 2
+
+# 1 "include/trace/events/module.h" 1
+
+
+
+
+
+
+# 1 "include/linux/tracepoint.h" 1
+# 8 "include/trace/events/module.h" 2
+
+
+
+struct module;
+
+
+
+
+
+
+extern struct tracepoint __tracepoint_module_load; static inline __attribute__((always_inline)) void trace_module_load(struct module *mod) { if (__builtin_expect(!!(__tracepoint_module_load.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_module_load)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_module_load)->funcs) *)&((&__tracepoint_module_load)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct module *mod))(*it_func))(mod); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_module_load(void (*probe)(struct module *mod)) { return tracepoint_probe_register("module_load", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_module_load(void (*probe)(struct module *mod)) { return tracepoint_probe_unregister("module_load", (void *)probe); };
+# 37 "include/trace/events/module.h"
+extern struct tracepoint __tracepoint_module_free; static inline __attribute__((always_inline)) void trace_module_free(struct module *mod) { if (__builtin_expect(!!(__tracepoint_module_free.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_module_free)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_module_free)->funcs) *)&((&__tracepoint_module_free)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct module *mod))(*it_func))(mod); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_module_free(void (*probe)(struct module *mod)) { return tracepoint_probe_register("module_free", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_module_free(void (*probe)(struct module *mod)) { return tracepoint_probe_unregister("module_free", (void *)probe); };
+# 54 "include/trace/events/module.h"
+extern struct tracepoint __tracepoint_module_get; static inline __attribute__((always_inline)) void trace_module_get(struct module *mod, unsigned long ip, int refcnt) { if (__builtin_expect(!!(__tracepoint_module_get.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_module_get)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_module_get)->funcs) *)&((&__tracepoint_module_get)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct module *mod, unsigned long ip, int refcnt))(*it_func))(mod, ip, refcnt); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_module_get(void (*probe)(struct module *mod, unsigned long ip, int refcnt)) { return tracepoint_probe_register("module_get", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_module_get(void (*probe)(struct module *mod, unsigned long ip, int refcnt)) { return tracepoint_probe_unregister("module_get", (void *)probe); };
+# 76 "include/trace/events/module.h"
+extern struct tracepoint __tracepoint_module_put; static inline __attribute__((always_inline)) void trace_module_put(struct module *mod, unsigned long ip, int refcnt) { if (__builtin_expect(!!(__tracepoint_module_put.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_module_put)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_module_put)->funcs) *)&((&__tracepoint_module_put)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(struct module *mod, unsigned long ip, int refcnt))(*it_func))(mod, ip, refcnt); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_module_put(void (*probe)(struct module *mod, unsigned long ip, int refcnt)) { return tracepoint_probe_register("module_put", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_module_put(void (*probe)(struct module *mod, unsigned long ip, int refcnt)) { return tracepoint_probe_unregister("module_put", (void *)probe); };
+# 98 "include/trace/events/module.h"
+extern struct tracepoint __tracepoint_module_request; static inline __attribute__((always_inline)) void trace_module_request(char *name, bool wait, unsigned long ip) { if (__builtin_expect(!!(__tracepoint_module_request.state), 0)) do { void **it_func; rcu_read_lock_sched_notrace(); it_func = ({ typeof((&__tracepoint_module_request)->funcs) _________p1 = (*(volatile typeof((&__tracepoint_module_request)->funcs) *)&((&__tracepoint_module_request)->funcs)); do { } while(0); (_________p1); }); if (it_func) { do { ((void(*)(char *name, bool wait, unsigned long ip))(*it_func))(name, wait, ip); } while (*(++it_func)); } rcu_read_unlock_sched_notrace(); } while (0); } static inline __attribute__((always_inline)) int register_trace_module_request(void (*probe)(char *name, bool wait, unsigned long ip)) { return tracepoint_probe_register("module_request", (void *)probe); } static inline __attribute__((always_inline)) int unregister_trace_module_request(void (*probe)(char *name, bool wait, unsigned long ip)) { return tracepoint_probe_unregister("module_request", (void *)probe); };
+# 125 "include/trace/events/module.h"
+# 1 "include/trace/define_trace.h" 1
+# 126 "include/trace/events/module.h" 2
+# 24 "include/linux/module.h" 2
+# 35 "include/linux/module.h"
+struct kernel_symbol
+{
+ unsigned long value;
+ const char *name;
+};
+
+struct modversion_info
+{
+ unsigned long crc;
+ char name[(64 - sizeof(unsigned long))];
+};
+
+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;
+ struct module_param_attrs *mp;
+};
+
+
+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);
+void trim_init_extable(struct module *m);
+
+
+
+
+
+
+extern struct module __this_module;
+# 170 "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);
+# 227 "include/linux/module.h"
+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_attribute *modinfo_attrs;
+ const char *version;
+ const char *srcversion;
+ struct kobject *holders_dir;
+
+
+ const struct kernel_symbol *syms;
+ const unsigned long *crcs;
+ unsigned int num_syms;
+
+
+ struct kernel_param *kp;
+ unsigned int num_kp;
+
+
+ unsigned int num_gpl_syms;
+ const struct kernel_symbol *gpl_syms;
+ const unsigned long *gpl_crcs;
+
+
+
+ const struct kernel_symbol *unused_syms;
+ const unsigned long *unused_crcs;
+ unsigned int num_unused_syms;
+
+
+ unsigned int num_unused_gpl_syms;
+ const struct kernel_symbol *unused_gpl_syms;
+ const unsigned long *unused_gpl_crcs;
+
+
+
+ const struct kernel_symbol *gpl_future_syms;
+ const unsigned long *gpl_future_crcs;
+ unsigned int num_gpl_future_syms;
+
+
+ unsigned int num_exentries;
+ struct exception_table_entry *extable;
+
+
+ int (*init)(void);
+
+
+ void *module_init;
+
+
+ void *module_core;
+
+
+ unsigned int init_size, core_size;
+
+
+ unsigned int init_text_size, core_text_size;
+
+
+ struct mod_arch_specific arch;
+
+ unsigned int taints;
+
+
+
+ unsigned num_bugs;
+ struct list_head bug_list;
+ struct bug_entry *bug_table;
+# 319 "include/linux/module.h"
+ Elf32_Sym *symtab, *core_symtab;
+ unsigned int num_symtab, core_num_syms;
+ char *strtab, *core_strtab;
+
+
+ struct module_sect_attrs *sect_attrs;
+
+
+ struct module_notes_attrs *notes_attrs;
+
+
+
+ void *percpu;
+
+
+
+ char *args;
+
+ struct tracepoint *tracepoints;
+ unsigned int num_tracepoints;
+
+
+
+ const char **trace_bprintk_fmt_start;
+ unsigned int num_trace_bprintk_fmt;
+
+
+ struct ftrace_event_call *trace_events;
+ unsigned int num_trace_events;
+# 356 "include/linux/module.h"
+ struct list_head modules_which_use_me;
+
+
+ struct task_struct *waiter;
+
+
+ void (*exit)(void);
+
+
+
+
+ local_t ref;
+
+
+
+
+
+ ctor_fn_t *ctors;
+ unsigned int num_ctors;
+
+};
+
+
+
+
+extern struct mutex module_mutex;
+
+
+
+
+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_address(unsigned long addr);
+bool is_module_address(unsigned long addr);
+bool is_module_text_address(unsigned long addr);
+
+static inline __attribute__((always_inline)) int within_module_core(unsigned long addr, struct module *mod)
+{
+ return (unsigned long)mod->module_core <= addr &&
+        addr < (unsigned long)mod->module_core + mod->core_size;
+}
+
+static inline __attribute__((always_inline)) int within_module_init(unsigned long addr, struct module *mod)
+{
+ return (unsigned long)mod->module_init <= addr &&
+        addr < (unsigned long)mod->module_init + mod->init_size;
+}
+
+
+struct module *find_module(const char *name);
+
+struct symsearch {
+ const struct kernel_symbol *start, *stop;
+ const unsigned long *crcs;
+ enum {
+  NOT_GPL_ONLY,
+  GPL_ONLY,
+  WILL_BE_GPL_ONLY,
+ } licence;
+ bool unused;
+};
+
+
+const struct kernel_symbol *find_symbol(const char *name,
+     struct module **owner,
+     const unsigned long **crc,
+     bool gplok,
+     bool warn);
+
+
+bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,
+       unsigned int symnum, void *data), void *data);
+
+
+
+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);
+
+int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
+          struct module *, unsigned long),
+       void *data);
+
+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)) local_t *__module_ref_addr(struct module *mod, int cpu)
+{
+
+
+
+ return &mod->ref;
+
+}
+
+
+
+static inline __attribute__((always_inline)) void __module_get(struct module *module)
+{
+ if (module) {
+  unsigned int cpu = ({ do { } while (0); 0; });
+  atomic_long_inc(&(__module_ref_addr(module, cpu))->a);
+  trace_module_get(module, ({ __label__ __here; __here: (unsigned long)&&__here; }),
+     atomic_long_read(&(__module_ref_addr(module, cpu))->a));
+  do { } while (0);
+ }
+}
+
+static inline __attribute__((always_inline)) int try_module_get(struct module *module)
+{
+ int ret = 1;
+
+ if (module) {
+  unsigned int cpu = ({ do { } while (0); 0; });
+  if (__builtin_expect(!!(module_is_live(module)), 1)) {
+   atomic_long_inc(&(__module_ref_addr(module, cpu))->a);
+   trace_module_get(module, ({ __label__ __here; __here: (unsigned long)&&__here; }),
+    atomic_long_read(&(__module_ref_addr(module, cpu))->a));
+  }
+  else
+   ret = 0;
+  do { } while (0);
+ }
+ return ret;
+}
+
+extern void module_put(struct module *module);
+# 512 "include/linux/module.h"
+int use_module(struct module *a, struct module *b);
+# 524 "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_tracepoints(void);
+extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
+# 665 "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);
+# 712 "include/linux/module.h"
+int module_bug_finalize(const Elf32_Ehdr *, const Elf32_Shdr *,
+    struct module *);
+void module_bug_cleanup(struct module *);
+# 24 "fs/sysv/super.c" 2
+
+
+# 1 "include/linux/buffer_head.h" 1
+# 11 "include/linux/buffer_head.h"
+# 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 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ioctl.h" 1
+# 1 "include/asm-generic/ioctl.h" 1
+# 73 "include/asm-generic/ioctl.h"
+extern unsigned int __invalid_size_argument_for_IOC;
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ioctl.h" 2
+# 5 "include/linux/ioctl.h" 2
+# 11 "include/linux/fs.h" 2
+# 35 "include/linux/fs.h"
+struct files_stat_struct {
+ int nr_files;
+ int nr_free_files;
+ int max_files;
+};
+
+struct inodes_stat_t {
+ int nr_inodes;
+ int nr_unused;
+ int dummy[5];
+};
+# 365 "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;
+}
+# 366 "include/linux/fs.h" 2
+# 1 "include/linux/dcache.h" 1
+
+
+
+
+
+# 1 "include/linux/rculist.h" 1
+# 18 "include/linux/rculist.h"
+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;
+ ({ if (!__builtin_constant_p(new) || ((new) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (prev->next) = (new); });
+ next->prev = new;
+}
+# 43 "include/linux/rculist.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);
+}
+# 64 "include/linux/rculist.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);
+}
+# 94 "include/linux/rculist.h"
+static inline __attribute__((always_inline)) void list_del_rcu(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+ entry->prev = ((void *) 0x00200200);
+}
+# 120 "include/linux/rculist.h"
+static inline __attribute__((always_inline)) void hlist_del_init_rcu(struct hlist_node *n)
+{
+ if (!hlist_unhashed(n)) {
+  __hlist_del(n);
+  n->pprev = ((void *)0);
+ }
+}
+# 136 "include/linux/rculist.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;
+ ({ if (!__builtin_constant_p(new) || ((new) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (new->prev->next) = (new); });
+ new->next->prev = new;
+ old->prev = ((void *) 0x00200200);
+}
+# 163 "include/linux/rculist.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);
+# 185 "include/linux/rculist.h"
+ sync();
+# 195 "include/linux/rculist.h"
+ last->next = at;
+ ({ if (!__builtin_constant_p(first) || ((first) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (head->next) = (first); });
+ first->prev = head;
+ at->prev = last;
+}
+# 283 "include/linux/rculist.h"
+static inline __attribute__((always_inline)) void hlist_del_rcu(struct hlist_node *n)
+{
+ __hlist_del(n);
+ n->pprev = ((void *) 0x00200200);
+}
+# 296 "include/linux/rculist.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;
+ ({ if (!__builtin_constant_p(new) || ((new) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (*new->pprev) = (new); });
+ if (next)
+  new->next->pprev = &new->next;
+ old->pprev = ((void *) 0x00200200);
+}
+# 328 "include/linux/rculist.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;
+ ({ if (!__builtin_constant_p(n) || ((n) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (h->first) = (n); });
+ if (first)
+  first->pprev = &n->next;
+}
+# 358 "include/linux/rculist.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;
+ ({ if (!__builtin_constant_p(n) || ((n) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (*(n->pprev)) = (n); });
+ next->pprev = &n->next;
+}
+# 385 "include/linux/rculist.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;
+ ({ if (!__builtin_constant_p(n) || ((n) != ((void *)0))) __asm__ __volatile__("": : :"memory"); (prev->next) = (n); });
+ if (n->next)
+  n->next->pprev = &n->next;
+}
+# 7 "include/linux/dcache.h" 2
+
+
+
+
+struct nameidata;
+struct path;
+struct vfsmount;
+# 33 "include/linux/dcache.h"
+struct qstr {
+ unsigned int hash;
+ unsigned int len;
+ const unsigned char *name;
+};
+
+struct dentry_stat_t {
+ int nr_dentry;
+ int nr_unused;
+ int age_limit;
+ int want_pages;
+ int dummy[2];
+};
+extern struct dentry_stat_t dentry_stat;
+
+
+
+
+
+
+static inline __attribute__((always_inline)) unsigned long
+partial_name_hash(unsigned long c, unsigned long prevhash)
+{
+ return (prevhash + (c << 4) + (c >> 4)) * 11;
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) unsigned long end_name_hash(unsigned long hash)
+{
+ return (unsigned int) hash;
+}
+
+
+static inline __attribute__((always_inline)) unsigned int
+full_name_hash(const unsigned char *name, unsigned int len)
+{
+ unsigned long hash = 0;
+ while (len--)
+  hash = partial_name_hash(*name++, hash);
+ return end_name_hash(hash);
+}
+# 89 "include/linux/dcache.h"
+struct dentry {
+ atomic_t d_count;
+ unsigned int d_flags;
+ spinlock_t d_lock;
+ int d_mounted;
+ 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;
+ const struct dentry_operations *d_op;
+ struct super_block *d_sb;
+ void *d_fsdata;
+
+ unsigned char d_iname[40];
+};
+
+
+
+
+
+
+
+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);
+};
+# 189 "include/linux/dcache.h"
+extern spinlock_t dcache_lock;
+extern seqlock_t rename_lock;
+# 208 "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)
+{
+ _spin_lock(&dcache_lock);
+ _spin_lock(&dentry->d_lock);
+  __d_drop(dentry);
+ _spin_unlock(&dentry->d_lock);
+ _spin_unlock(&dcache_lock);
+}
+
+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_splice_alias(struct inode *, struct dentry *);
+extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
+extern struct dentry * d_obtain_alias(struct inode *);
+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 *);
+# 274 "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);
+}
+# 288 "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_ancestor(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(const struct path *, char *, int);
+extern char *dentry_path(struct dentry *, char *, int);
+# 333 "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 { asm volatile( "1:     .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/dcache.h"), "i"(336), "i"(0), "i"(sizeof(struct bug_entry))); for (;;); } while (0); } while(0);
+  atomic_inc(&dentry->d_count);
+ }
+ return dentry;
+}
+
+extern struct dentry * dget_locked(struct dentry *);
+# 351 "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)) int d_unlinked(struct dentry *dentry)
+{
+ return d_unhashed(dentry) && !((dentry) == (dentry)->d_parent);
+}
+
+static inline __attribute__((always_inline)) struct dentry *dget_parent(struct dentry *dentry)
+{
+ struct dentry *ret;
+
+ _spin_lock(&dentry->d_lock);
+ ret = dget(dentry->d_parent);
+ _spin_unlock(&dentry->d_lock);
+ 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 path *);
+extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
+
+extern int sysctl_vfs_cache_pressure;
+# 367 "include/linux/fs.h" 2
+# 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 *);
+# 368 "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;
+};
+# 137 "include/linux/radix-tree.h"
+static inline __attribute__((always_inline)) void *radix_tree_deref_slot(void **pslot)
+{
+ void *ret = ({ typeof(*pslot) _________p1 = (*(volatile typeof(*pslot) *)&(*pslot)); do { } while(0); (_________p1); });
+ if (__builtin_expect(!!(radix_tree_is_indirect_ptr(ret)), 0))
+  ret = ((void *)-1UL);
+ return ret;
+}
+# 152 "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 { asm volatile( "1:    .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/radix-tree.h"), "i"(154), "i"(0), "i"(sizeof(struct bug_entry))); for (;;); } 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 int
+radix_tree_gang_lookup_slot(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);
+unsigned long radix_tree_prev_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);
+unsigned int
+radix_tree_gang_lookup_tag_slot(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);
+}
+# 373 "include/linux/fs.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);
+# 374 "include/linux/fs.h" 2
+
+# 1 "include/linux/pid.h" 1
+
+
+
+
+
+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;
+ unsigned int level;
+
+ struct hlist_head tasks[PIDTYPE_MAX];
+ struct rcu_head rcu;
+ 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;
+# 112 "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_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);
+# 135 "include/linux/pid.h"
+static inline __attribute__((always_inline)) struct pid_namespace *ns_of_pid(struct pid *pid)
+{
+ struct pid_namespace *ns = ((void *)0);
+ if (pid)
+  ns = pid->numbers[pid->level].ns;
+ return ns;
+}
+# 154 "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);
+# 376 "include/linux/fs.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];
+};
+# 96 "include/linux/capability.h"
+extern int file_caps_enabled;
+
+
+typedef struct kernel_cap_struct {
+ __u32 cap[2];
+} kernel_cap_t;
+
+
+struct cpu_vfs_cap_data {
+ __u32 magic_etc;
+ kernel_cap_t permitted;
+ kernel_cap_t inheritable;
+};
+# 444 "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;
+}
+# 492 "include/linux/capability.h"
+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 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((9) & 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 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((9) & 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 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((9) & 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 << ((27) & 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 << ((27) & 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;
+# 565 "include/linux/capability.h"
+extern int capable(int cap);
+
+
+struct dentry;
+extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
+# 378 "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;
+};
+# 32 "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 = { 1 }, .magic = 0xdead4ead, .owner = ((void *)-1L), .owner_cpu = -1, .dep_map = { .name = "(*sem).lock" } }, .count = val, .wait_list = { &((*sem).wait_list), &((*sem).wait_list) }, };
+ lockdep_init_map(&sem->lock.dep_map, "semaphore->lock", &__key, 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);
+# 379 "include/linux/fs.h" 2
+# 1 "include/linux/fiemap.h" 1
+# 16 "include/linux/fiemap.h"
+struct fiemap_extent {
+ __u64 fe_logical;
+
+ __u64 fe_physical;
+
+ __u64 fe_length;
+ __u64 fe_reserved64[2];
+ __u32 fe_flags;
+ __u32 fe_reserved[3];
+};
+
+struct fiemap {
+ __u64 fm_start;
+
+ __u64 fm_length;
+
+ __u32 fm_flags;
+ __u32 fm_mapped_extents;
+ __u32 fm_extent_count;
+ __u32 fm_reserved;
+ struct fiemap_extent fm_extents[0];
+};
+# 380 "include/linux/fs.h" 2
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/byteorder.h" 1
+# 383 "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;
+struct cred;
+
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) inode_init(void);
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) inode_init_early(void);
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) files_init(unsigned long);
+
+extern struct files_stat_struct files_stat;
+extern int get_max_files(void);
+extern int sysctl_nr_open;
+extern struct inodes_stat_t inodes_stat;
+extern int leases_enable, lease_break_time;
+
+extern int dir_notify_enable;
+
+
+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);
+# 446 "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
+# 86 "include/linux/quota.h"
+enum {
+ QIF_BLIMITS_B = 0,
+ QIF_SPACE_B,
+ QIF_ILIMITS_B,
+ QIF_INODES_B,
+ QIF_BTIME_B,
+ QIF_ITIME_B,
+};
+# 106 "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;
+};
+# 127 "include/linux/quota.h"
+struct if_dqinfo {
+ __u64 dqi_bgrace;
+ __u64 dqi_igrace;
+ __u32 dqi_flags;
+ __u32 dqi_valid;
+};
+# 149 "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,
+};
+# 176 "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;
+# 177 "include/linux/quota.h" 2
+# 1 "include/linux/dqblk_v1.h" 1
+# 178 "include/linux/quota.h" 2
+# 1 "include/linux/dqblk_v2.h" 1
+
+
+
+
+
+
+
+# 1 "include/linux/dqblk_qtree.h" 1
+# 17 "include/linux/dqblk_qtree.h"
+struct dquot;
+
+
+struct qtree_fmt_operations {
+ void (*mem2disk_dqblk)(void *disk, struct dquot *dquot);
+ void (*disk2mem_dqblk)(struct dquot *dquot, void *disk);
+ int (*is_id)(void *disk, struct dquot *dquot);
+};
+
+
+struct qtree_mem_dqinfo {
+ struct super_block *dqi_sb;
+ int dqi_type;
+ unsigned int dqi_blocks;
+ unsigned int dqi_free_blk;
+ unsigned int dqi_free_entry;
+ unsigned int dqi_blocksize_bits;
+ unsigned int dqi_entry_size;
+ unsigned int dqi_usable_bs;
+ unsigned int dqi_qtree_depth;
+ struct qtree_fmt_operations *dqi_ops;
+};
+
+int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_delete_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_entry_unused(struct qtree_mem_dqinfo *info, char *disk);
+static inline __attribute__((always_inline)) int qtree_depth(struct qtree_mem_dqinfo *info)
+{
+ unsigned int epb = info->dqi_usable_bs >> 2;
+ unsigned long long entries = epb;
+ int i;
+
+ for (i = 1; entries < (1ULL << 32); i++)
+  entries *= epb;
+ return i;
+}
+# 9 "include/linux/dqblk_v2.h" 2
+# 179 "include/linux/quota.h" 2
+
+
+
+typedef __kernel_uid32_t qid_t;
+typedef long long qsize_t;
+
+extern spinlock_t dq_data_lock;
+# 197 "include/linux/quota.h"
+struct mem_dqblk {
+ qsize_t dqb_bhardlimit;
+ qsize_t dqb_bsoftlimit;
+ qsize_t dqb_curspace;
+ qsize_t dqb_rsvspace;
+ qsize_t dqb_ihardlimit;
+ qsize_t dqb_isoftlimit;
+ qsize_t 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;
+ void *dqi_priv;
+};
+
+struct super_block;
+
+
+
+
+
+extern void mark_info_dirty(struct super_block *sb, int type);
+static inline __attribute__((always_inline)) int info_dirty(struct mem_dqinfo *info)
+{
+ return test_bit(16, &info->dqi_flags);
+}
+
+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;
+# 264 "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 *, qsize_t);
+ int (*free_space) (struct inode *, qsize_t);
+ int (*free_inode) (const struct inode *, qsize_t);
+ int (*transfer) (struct inode *, struct iattr *);
+ int (*write_dquot) (struct dquot *);
+ struct dquot *(*alloc_dquot)(struct super_block *, int);
+ void (*destroy_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);
+
+ int (*reserve_space) (struct inode *, qsize_t, int);
+
+ int (*claim_space) (struct inode *, qsize_t);
+
+ void (*release_rsv) (struct inode *, qsize_t);
+
+ qsize_t (*get_reserved_space) (struct inode *);
+};
+
+
+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;
+};
+
+
+enum {
+ _DQUOT_USAGE_ENABLED = 0,
+ _DQUOT_LIMITS_ENABLED,
+ _DQUOT_SUSPENDED,
+
+
+ _DQUOT_STATE_FLAGS
+};
+# 365 "include/linux/quota.h"
+static inline __attribute__((always_inline)) unsigned int dquot_state_flag(unsigned int flags, int type)
+{
+ if (type == 0)
+  return flags;
+ return flags << _DQUOT_STATE_FLAGS;
+}
+
+static inline __attribute__((always_inline)) unsigned int dquot_generic_flag(unsigned int flags, int type)
+{
+ if (type == 0)
+  return flags;
+ return flags >> _DQUOT_STATE_FLAGS;
+}
+
+struct quota_info {
+ unsigned int flags;
+ struct mutex dqio_mutex;
+ struct mutex dqonoff_mutex;
+ struct rw_semaphore dqptr_sem;
+ struct inode *files[2];
+ struct mem_dqinfo info[2];
+ struct quota_format_ops *ops[2];
+};
+
+int 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;
+};
+# 468 "include/linux/fs.h" 2
+# 495 "include/linux/fs.h"
+enum positive_aop_returns {
+ AOP_WRITEPAGE_ACTIVATE = 0x80000,
+ AOP_TRUNCATED_PAGE = 0x80001,
+};
+# 509 "include/linux/fs.h"
+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;
+}
+# 554 "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);
+
+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 (*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 (*is_partially_uptodate) (struct page *, read_descriptor_t *,
+     unsigned long);
+ int (*error_remove_page)(struct address_space *, 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;
+ spinlock_t tree_lock;
+ unsigned int i_mmap_writable;
+ struct prio_tree_root i_mmap;
+ struct list_head i_mmap_nonlinear;
+ spinlock_t i_mmap_lock;
+ unsigned int truncate_count;
+ unsigned long nrpages;
+ unsigned long writeback_index;
+ 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;
+ struct super_block * bd_super;
+ int bd_openers;
+ struct mutex bd_mutex;
+ struct list_head bd_inodes;
+ void * bd_holder;
+ int bd_holders;
+
+ struct list_head bd_holder_list;
+
+ struct block_device * bd_contains;
+ unsigned bd_block_size;
+ struct hd_struct * bd_part;
+
+ unsigned bd_part_count;
+ int bd_invalidated;
+ struct gendisk * bd_disk;
+ struct list_head bd_list;
+
+
+
+
+
+
+ unsigned long bd_private;
+
+
+ int bd_fsfreeze_count;
+
+ struct mutex bd_fsfreeze_mutex;
+};
+# 683 "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;
+}
+# 716 "include/linux/fs.h"
+struct posix_acl;
+
+
+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;
+ blkcnt_t i_blocks;
+ unsigned int i_blkbits;
+ 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;
+ };
+
+ __u32 i_generation;
+
+
+ __u32 i_fsnotify_mask;
+ struct hlist_head i_fsnotify_mark_entries;
+
+
+
+ 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_security;
+
+
+ struct posix_acl *i_acl;
+ struct posix_acl *i_default_acl;
+
+ void *i_private;
+};
+# 800 "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
+};
+# 819 "include/linux/fs.h"
+static inline __attribute__((always_inline)) loff_t i_size_read(const struct inode *inode)
+{
+# 838 "include/linux/fs.h"
+ return inode->i_size;
+
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void i_size_write(struct inode *inode, loff_t i_size)
+{
+# 858 "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;
+ unsigned 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;
+ spinlock_t f_lock;
+ atomic_long_t f_count;
+ unsigned int f_flags;
+ fmode_t f_mode;
+ loff_t f_pos;
+ struct fown_struct f_owner;
+ const struct cred *f_cred;
+ struct file_ra_state f_ra;
+
+ u64 f_version;
+
+ void *f_security;
+
+
+ void *private_data;
+
+
+
+ struct list_head f_ep_links;
+
+ struct address_space *f_mapping;
+
+ unsigned long f_mnt_write_state;
+
+};
+extern spinlock_t files_lock;
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void file_take_write(struct file *f)
+{
+ ({ int __ret_warn_on = !!(f->f_mnt_write_state != 0); if (__builtin_expect(!!(__ret_warn_on), 0)) asm volatile( "1:   .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/fs.h"), "i"(956), "i"((1<<0)), "i"(sizeof(struct bug_entry))); __builtin_expect(!!(__ret_warn_on), 0); });
+ f->f_mnt_write_state = 1;
+}
+static inline __attribute__((always_inline)) void file_release_write(struct file *f)
+{
+ f->f_mnt_write_state |= 2;
+}
+static inline __attribute__((always_inline)) void file_reset_write(struct file *f)
+{
+ f->f_mnt_write_state = 0;
+}
+static inline __attribute__((always_inline)) void file_check_state(struct file *f)
+{
+
+
+
+
+ ({ int __ret_warn_on = !!(f->f_mnt_write_state == 1); if (__builtin_expect(!!(__ret_warn_on), 0)) asm volatile( "1:   .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/fs.h"), "i"(973), "i"((1<<0)), "i"(sizeof(struct bug_entry))); __builtin_expect(!!(__ret_warn_on), 0); });
+ ({ int __ret_warn_on = !!(f->f_mnt_write_state == 2); if (__builtin_expect(!!(__ret_warn_on), 0)) asm volatile( "1:   .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/fs.h"), "i"(974), "i"((1<<0)), "i"(sizeof(struct bug_entry))); __builtin_expect(!!(__ret_warn_on), 0); });
+}
+static inline __attribute__((always_inline)) int file_check_writeable(struct file *f)
+{
+ if (f->f_mnt_write_state == 1)
+  return 0;
+ printk("<4>" "writeable file with no "
+       "mnt_want_write()\n");
+ ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) asm volatile( "1:   .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/fs.h"), "i"(982), "i"((1<<0)), "i"(sizeof(struct bug_entry))); __builtin_expect(!!(__ret_warn_on), 0); });
+ return -22;
+}
+# 1027 "include/linux/fs.h"
+typedef struct files_struct *fl_owner_t;
+
+struct file_lock_operations {
+ 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);
+};
+
+struct lock_manager {
+ struct list_head list;
+};
+
+void locks_start_grace(struct lock_manager *);
+void locks_end_grace(struct lock_manager *);
+int locks_in_grace(void);
+
+
+# 1 "include/linux/nfs_fs_i.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/types.h" 1
+# 5 "include/linux/nfs_fs_i.h" 2
+
+# 1 "include/linux/nfs.h" 1
+# 40 "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,
+};
+
+
+
+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;
+# 193 "include/linux/sunrpc/msg_prot.h"
+# 1 "include/linux/inet.h" 1
+# 54 "include/linux/inet.h"
+extern __be32 in_aton(const char *str);
+extern int in4_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);
+extern int in6_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);
+# 194 "include/linux/sunrpc/msg_prot.h" 2
+# 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;
+};
+# 1055 "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 char fl_flags;
+ unsigned char fl_type;
+ unsigned int fl_pid;
+ struct pid *fl_nspid;
+ wait_queue_head_t fl_wait;
+ struct file *fl_file;
+ loff_t fl_start;
+ loff_t fl_end;
+
+ struct fasync_struct * fl_fasync;
+ unsigned long fl_break_time;
+
+ const struct file_lock_operations *fl_ops;
+ const 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;
+};
+# 1092 "include/linux/fs.h"
+# 1 "include/linux/fcntl.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/fcntl.h" 1
+# 17 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/fcntl.h"
+# 1 "include/asm-generic/fcntl.h" 1
+# 94 "include/asm-generic/fcntl.h"
+struct f_owner_ex {
+ int type;
+ pid_t pid;
+};
+# 139 "include/asm-generic/fcntl.h"
+struct flock {
+ short l_type;
+ short l_whence;
+ __kernel_off_t l_start;
+ __kernel_off_t l_len;
+ __kernel_pid_t l_pid;
+
+};
+# 156 "include/asm-generic/fcntl.h"
+struct flock64 {
+ short l_type;
+ short l_whence;
+ __kernel_loff_t l_start;
+ __kernel_loff_t l_len;
+ __kernel_pid_t l_pid;
+
+};
+# 18 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/fcntl.h" 2
+# 5 "include/linux/fcntl.h" 2
+# 1093 "include/linux/fs.h" 2
+
+extern void send_sigio(struct fown_struct *fown, int fd, int band);
+
+
+extern int do_sync_mapping_range(struct address_space *mapping, loff_t offset,
+   loff_t endbyte, unsigned int flags);
+
+
+extern int fcntl_getlk(struct file *, struct flock *);
+extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
+   struct flock *);
+
+
+extern int fcntl_getlk64(struct file *, struct flock64 *);
+extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
+   struct flock64 *);
+
+
+extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
+extern int fcntl_getlease(struct file *filp);
+
+
+extern void locks_init_lock(struct file_lock *);
+extern void locks_copy_lock(struct file_lock *, struct file_lock *);
+extern void __locks_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 locks_release_private(struct file_lock *);
+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);
+# 1281 "include/linux/fs.h"
+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);
+# 1311 "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;
+ loff_t s_maxbytes;
+ struct file_system_type *s_type;
+ const struct super_operations *s_op;
+ const struct dquot_operations *dq_op;
+ const 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_need_sync;
+ atomic_t s_active;
+
+ void *s_security;
+
+ struct xattr_handler **s_xattr;
+
+ struct list_head s_inodes;
+ struct hlist_head s_anon;
+ struct list_head s_files;
+
+ struct list_head s_dentry_lru;
+ int s_nr_dentry_unused;
+
+ struct block_device *s_bdev;
+ struct backing_dev_info *s_bdi;
+ 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;
+ fmode_t s_mode;
+
+
+
+
+
+ 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,
+};
+# 1407 "include/linux/fs.h"
+extern void lock_super(struct super_block *);
+extern void unlock_super(struct super_block *);
+
+
+
+
+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 *);
+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);
+
+
+
+
+struct fiemap_extent_info {
+ unsigned int fi_flags;
+ unsigned int fi_extents_mapped;
+ unsigned int fi_extents_max;
+ struct fiemap_extent *fi_extents_start;
+
+};
+int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
+       u64 phys, u64 len, u32 flags);
+int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
+# 1468 "include/linux/fs.h"
+typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
+struct block_device_operations;
+# 1482 "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 (*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);
+ int (*check_acl)(struct inode *, int);
+ 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);
+ int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
+        u64 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);
+ int (*freeze_fs) (struct super_block *);
+ int (*unfreeze_fs) (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);
+
+ int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
+};
+# 1649 "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);
+}
+# 1668 "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);
+}
+# 1690 "include/linux/fs.h"
+static inline __attribute__((always_inline)) void drop_nlink(struct inode *inode)
+{
+ inode->i_nlink--;
+}
+# 1703 "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);
+}
+# 1722 "include/linux/fs.h"
+static inline __attribute__((always_inline)) void inode_inc_iversion(struct inode *inode)
+{
+       _spin_lock(&inode->i_lock);
+       inode->i_version++;
+       _spin_unlock(&inode->i_lock);
+}
+
+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_ns(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_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);
+void deactivate_locked_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 void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
+int __put_super_and_need_restart(struct super_block *sb);
+void put_super(struct super_block *sb);
+
+
+
+
+
+
+
+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 path *);
+extern void drop_collected_mounts(struct vfsmount *);
+
+extern int vfs_statfs(struct dentry *, struct kstatfs *);
+
+extern int current_umask(void);
+
+
+extern struct kobject *fs_kobj;
+
+extern int rw_verify_area(int, struct file *, loff_t *, size_t);
+
+
+
+
+
+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;
+}
+
+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;
+}
+# 1912 "include/linux/fs.h"
+extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
+         struct file *filp);
+extern int do_fallocate(struct file *file, int mode, loff_t offset,
+   loff_t len);
+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,
+     const struct cred *);
+extern int filp_close(struct file *, fl_owner_t id);
+extern char * getname(const char *);
+
+
+
+extern int ioctl_preallocate(struct file *filp, void *argp);
+
+
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) vfs_caches_init_early(void);
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) vfs_caches_init(unsigned long);
+
+extern struct kmem_cache *names_cachep;
+# 1944 "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 struct block_device *bdgrab(struct block_device *bdev);
+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, fmode_t);
+extern void invalidate_bdev(struct block_device *);
+extern int sync_blockdev(struct block_device *bdev);
+extern struct super_block *freeze_bdev(struct block_device *);
+extern void emergency_thaw_all(void);
+extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
+extern int fsync_bdev(struct block_device *);
+# 1973 "include/linux/fs.h"
+extern int sync_filesystem(struct super_block *);
+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 block_device *, fmode_t, unsigned, unsigned long);
+extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
+extern int blkdev_get(struct block_device *, fmode_t);
+extern int blkdev_put(struct block_device *, fmode_t);
+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 *);
+# 1997 "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 major, unsigned int baseminor,
+        unsigned int count, const char *name,
+        const struct file_operations *fops);
+extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
+    unsigned int count, const char *name);
+extern void unregister_chrdev_region(dev_t, unsigned);
+extern void chrdev_show(struct seq_file *,off_t);
+
+static inline __attribute__((always_inline)) int register_chrdev(unsigned int major, const char *name,
+      const struct file_operations *fops)
+{
+ return __register_chrdev(major, 0, 256, name, fops);
+}
+
+static inline __attribute__((always_inline)) void unregister_chrdev(unsigned int major, const char *name)
+{
+ __unregister_chrdev(major, 0, 256, name);
+}
+
+
+
+
+
+
+
+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_exclusive(const char *, fmode_t, void *);
+extern void close_bdev_exclusive(struct block_device *, fmode_t);
+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_pipefifo_fops;
+extern const struct file_operations write_pipefifo_fops;
+extern const struct file_operations rdwr_pipefifo_fops;
+
+extern int fs_may_remount_ro(struct super_block *);
+# 2058 "include/linux/fs.h"
+extern void check_disk_size_change(struct gendisk *disk,
+       struct block_device *bdev);
+extern int revalidate_disk(struct gendisk *);
+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);
+
+static inline __attribute__((always_inline)) unsigned long
+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_fdatawait_range(struct address_space *, loff_t lstart,
+       loff_t lend);
+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 int filemap_fdatawrite_range(struct address_space *mapping,
+    loff_t start, loff_t end);
+
+extern int vfs_fsync_range(struct file *file, struct dentry *dentry,
+      loff_t start, loff_t end, int datasync);
+extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
+extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
+extern void sync_supers(void);
+extern void emergency_sync(void);
+extern void emergency_remount(void);
+
+extern sector_t bmap(struct inode *, sector_t);
+
+extern int notify_change(struct dentry *, struct iattr *);
+extern int inode_permission(struct inode *, int);
+extern int generic_permission(struct inode *, int,
+  int (*check_acl)(struct inode *, int));
+
+static inline __attribute__((always_inline)) bool execute_ok(struct inode *inode)
+{
+ return (inode->i_mode & (00100|00010|00001)) || (((inode->i_mode) & 00170000) == 0040000);
+}
+
+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_flags(int *, int);
+extern struct file *create_read_pipe(struct file *f, int flags);
+extern struct file *create_write_pipe(int flags);
+extern void free_write_pipe(struct file *);
+
+extern struct file *do_filp_open(int dfd, const char *pathname,
+  int open_flag, int mode, int acc_mode);
+extern int may_open(struct path *, int, int);
+
+extern int kernel_read(struct file *, loff_t, 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
+
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/errno.h" 1
+# 7 "include/linux/err.h" 2
+# 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;
+}
+# 2148 "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 int inode_init_always(struct super_block *, struct inode *);
+extern void inode_init_once(struct inode *);
+extern void inode_add_to_lists(struct super_block *, 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 int generic_detach_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 int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
+extern int insert_inode_locked(struct inode *);
+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 void __destroy_inode(struct inode *);
+extern struct inode *new_inode(struct super_block *);
+extern int should_remove_suid(struct dentry *);
+extern int file_remove_suid(struct file *);
+
+extern void __insert_inode_hash(struct inode *, unsigned long hashval);
+extern void remove_inode_hash(struct inode *);
+static inline __attribute__((always_inline)) void insert_inode_hash(struct inode *inode) {
+ __insert_inode_hash(inode, inode->i_ino);
+}
+
+extern struct file * get_empty_filp(void);
+extern void file_move(struct file *f, struct list_head *list);
+extern void file_kill(struct file *f);
+
+struct bio;
+extern void submit_bio(int, struct bio *);
+extern int bdev_read_only(struct block_device *);
+
+extern int set_blocksize(struct block_device *, int);
+extern int sb_set_blocksize(struct super_block *, int);
+extern int sb_min_blocksize(struct super_block *, int);
+
+extern int generic_file_mmap(struct file *, struct vm_area_struct *);
+extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
+extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
+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(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 blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
+    unsigned long nr_segs, loff_t pos);
+
+
+extern ssize_t generic_file_splice_read(struct file *, loff_t *,
+  struct pipe_inode_info *, size_t, unsigned int);
+extern ssize_t default_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_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 generic_file_llseek_unlocked(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);
+# 2255 "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,
+  int nofs);
+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_fstat(unsigned int, struct kstat *);
+extern int vfs_fstatat(int , char *, struct kstat *, int);
+
+extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
+      unsigned long arg);
+extern int __generic_block_fiemap(struct inode *inode,
+      struct fiemap_extent_info *fieinfo, u64 start,
+      u64 len, get_block_t *get_block);
+extern int generic_block_fiemap(struct inode *inode,
+    struct fiemap_extent_info *fieinfo, u64 start,
+    u64 len, get_block_t *get_block);
+
+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 *get_active_super(struct block_device *bdev);
+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 *to, size_t count,
+   loff_t *ppos, const void *from, size_t available);
+
+extern int simple_fsync(struct file *, struct dentry *, int);
+# 2390 "include/linux/fs.h"
+extern int inode_change_ok(const struct inode *, struct iattr *);
+extern int inode_newsize_ok(const struct inode *, loff_t offset);
+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);
+extern void replace_mount_options(struct super_block *sb, char *options);
+
+static inline __attribute__((always_inline)) ino_t parent_ino(struct dentry *dentry)
+{
+ ino_t res;
+
+ _spin_lock(&dentry->d_lock);
+ res = dentry->d_parent->d_inode->i_ino;
+ _spin_unlock(&dentry->d_lock);
+ 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);
+
+void simple_transaction_set(struct file *file, size_t n);
+# 2461 "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);
+
+struct ctl_table;
+int proc_nr_files(struct ctl_table *table, int write,
+    void *buffer, size_t *lenp, loff_t *ppos);
+
+int __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) get_filesystem_list(char *buf);
+# 12 "include/linux/buffer_head.h" 2
+
+# 1 "include/linux/pagemap.h" 1
+
+
+
+
+
+
+# 1 "include/linux/mm.h" 1
+# 11 "include/linux/mm.h"
+# 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(const struct rb_node *);
+extern struct rb_node *rb_prev(const struct rb_node *);
+extern struct rb_node *rb_first(const struct rb_root *);
+extern struct rb_node *rb_last(const 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/mm_types.h" 1
+
+
+
+# 1 "include/linux/auxvec.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/auxvec.h" 1
+# 1 "include/asm-generic/auxvec.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/auxvec.h" 2
+# 5 "include/linux/auxvec.h" 2
+# 5 "include/linux/mm_types.h" 2
+# 14 "include/linux/mm_types.h"
+# 1 "include/linux/page-debug-flags.h" 1
+# 14 "include/linux/page-debug-flags.h"
+enum page_debug_flags {
+ PAGE_DEBUG_FLAG_POISON,
+};
+# 15 "include/linux/mm_types.h" 2
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/mmu.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/mmu.h"
+struct sram_list_struct {
+ struct sram_list_struct *next;
+ void *addr;
+ size_t length;
+};
+
+typedef struct {
+ unsigned long end_brk;
+ unsigned long stack_start;
+
+
+
+ void *l1_stack_save;
+
+ struct sram_list_struct *sram_list;
+
+
+ unsigned long exec_fdpic_loadmap;
+ unsigned long interp_fdpic_loadmap;
+
+
+
+
+} mm_context_t;
+# 17 "include/linux/mm_types.h" 2
+
+
+
+
+
+
+struct address_space;
+
+
+
+
+
+
+typedef unsigned long mm_counter_t;
+# 40 "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;
+# 99 "include/linux/mm_types.h"
+ unsigned long debug_flags;
+# 109 "include/linux/mm_types.h"
+};
+
+
+
+
+
+
+struct vm_region {
+ struct rb_node vm_rb;
+ unsigned long vm_flags;
+ unsigned long vm_start;
+ unsigned long vm_end;
+ unsigned long vm_top;
+ unsigned long vm_pgoff;
+ struct file *vm_file;
+
+ atomic_t vm_usage;
+};
+
+
+
+
+
+
+
+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;
+
+
+ const struct vm_operations_struct *vm_ops;
+
+
+ unsigned long vm_pgoff;
+
+ struct file * vm_file;
+ void * vm_private_data;
+ unsigned long vm_truncate_count;
+
+
+ struct vm_region *vm_region;
+
+
+
+
+};
+
+struct core_thread {
+ struct task_struct *task;
+ struct core_thread *next;
+};
+
+struct core_state {
+ atomic_t nr_threads;
+ struct core_thread dumper;
+ struct completion startup;
+};
+
+struct mm_struct {
+ struct vm_area_struct * mmap;
+ struct rb_root mm_rb;
+ struct vm_area_struct * mmap_cache;
+ unsigned long (*get_unmapped_area) (struct file *filp,
+    unsigned long addr, unsigned long len,
+    unsigned long pgoff, unsigned long flags);
+ void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
+ unsigned long mmap_base;
+ unsigned long task_size;
+ unsigned long cached_hole_size;
+ unsigned long free_area_cache;
+ pgd_t * pgd;
+ atomic_t mm_users;
+ atomic_t mm_count;
+ int map_count;
+ struct rw_semaphore mmap_sem;
+ spinlock_t page_table_lock;
+
+ struct list_head mmlist;
+
+
+
+
+
+
+
+ mm_counter_t _file_rss;
+ mm_counter_t _anon_rss;
+
+ unsigned long hiwater_rss;
+ unsigned long hiwater_vm;
+
+ unsigned long total_vm, locked_vm, shared_vm, exec_vm;
+ unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
+ unsigned long start_code, end_code, start_data, end_data;
+ unsigned long start_brk, brk, start_stack;
+ unsigned long arg_start, arg_end, env_start, env_end;
+
+ unsigned long saved_auxv[(2*(0 + 19 + 1))];
+
+ struct linux_binfmt *binfmt;
+
+ cpumask_t cpu_vm_mask;
+
+
+ mm_context_t context;
+# 257 "include/linux/mm_types.h"
+ unsigned int faultstamp;
+ unsigned int token_priority;
+ unsigned int last_interval;
+
+ unsigned long flags;
+
+ struct core_state *core_state;
+
+ spinlock_t ioctx_lock;
+ struct hlist_head ioctx_list;
+# 284 "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;
+struct rlimit;
+
+
+extern unsigned long max_mapnr;
+
+
+extern unsigned long num_physpages;
+extern unsigned long totalram_pages;
+extern void * high_memory;
+extern int page_cluster;
+
+
+extern int sysctl_legacy_va_layout;
+
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h" 1
+# 10 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h"
+# 1 "include/asm-generic/4level-fixup.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h" 2
+
+
+
+
+typedef pte_t *pte_addr_t;
+# 40 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h"
+extern void paging_init(void);
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int pte_file(pte_t pte)
+{
+ return 0;
+}
+# 68 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h"
+static inline __attribute__((always_inline)) pte_t pte_rdprotect(pte_t _pte) { _pte.pte &= ~(0x00000004); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkread(pte_t _pte) { _pte.pte |= (0x00000004); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_wrprotect(pte_t _pte) { _pte.pte &= ~(0x00000008); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkwrite(pte_t _pte) { _pte.pte |= (0x00000008); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_exprotect(pte_t _pte) { _pte.pte &= ~(0x00000004 | 0x00000008); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkexec(pte_t _pte) { _pte.pte |= (0x00000004 | 0x00000008); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkclean(pte_t _pte) { _pte.pte &= ~(0x00000080); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkdirty(pte_t _pte) { _pte.pte |= (0x00000080); return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkold(pte_t _pte) { _pte.pte &= ~0x00000010 | 0x00000004 | 0x00000008; return _pte; };
+static inline __attribute__((always_inline)) pte_t pte_mkyoung(pte_t _pte) { _pte.pte |= 0x00000010 | 0x00000004 | 0x00000008; return _pte; };
+
+
+
+
+
+
+extern char empty_zero_page[];
+
+extern unsigned int kobjsize(const void *objp);
+# 103 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h"
+extern unsigned long get_fb_unmapped_area(struct file *filp, unsigned long,
+       unsigned long, unsigned long,
+       unsigned long);
+
+
+# 1 "include/asm-generic/pgtable.h" 1
+# 309 "include/asm-generic/pgtable.h"
+static inline __attribute__((always_inline)) int track_pfn_vma_new(struct vm_area_struct *vma, pgprot_t *prot,
+     unsigned long pfn, unsigned long size)
+{
+ return 0;
+}
+# 322 "include/asm-generic/pgtable.h"
+static inline __attribute__((always_inline)) int track_pfn_vma_copy(struct vm_area_struct *vma)
+{
+ return 0;
+}
+# 335 "include/asm-generic/pgtable.h"
+static inline __attribute__((always_inline)) void untrack_pfn_vma(struct vm_area_struct *vma,
+     unsigned long pfn, unsigned long size)
+{
+}
+# 109 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/pgtable.h" 2
+# 40 "include/linux/mm.h" 2
+# 56 "include/linux/mm.h"
+extern struct kmem_cache *vm_area_cachep;
+
+
+extern struct rb_root nommu_region_tree;
+extern struct rw_semaphore nommu_region_sem;
+
+extern unsigned int kobjsize(const void *objp);
+# 134 "include/linux/mm.h"
+extern pgprot_t protection_map[16];
+# 148 "include/linux/mm.h"
+static inline __attribute__((always_inline)) int is_linear_pfn_mapping(struct vm_area_struct *vma)
+{
+ return (vma->vm_flags & 0x40000000);
+}
+
+static inline __attribute__((always_inline)) int is_pfn_mapping(struct vm_area_struct *vma)
+{
+ return (vma->vm_flags & 0x00000400);
+}
+# 167 "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);
+
+
+
+ int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);
+
+
+
+
+ int (*access)(struct vm_area_struct *vma, unsigned long addr,
+        void *buf, int len, int write);
+# 223 "include/linux/mm.h"
+};
+
+struct mmu_gather;
+struct inode;
+# 235 "include/linux/mm.h"
+# 1 "include/linux/page-flags.h" 1
+# 75 "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_private_2,
+ PG_writeback,
+
+ PG_head,
+ PG_tail,
+
+
+
+ PG_swapcache,
+ PG_mappedtodisk,
+ PG_reclaim,
+ PG_buddy,
+ PG_swapbacked,
+ PG_unevictable,
+# 111 "include/linux/page-flags.h"
+ __NR_PAGEFLAGS,
+
+
+ PG_checked = PG_owner_priv_1,
+
+
+
+
+
+ PG_fscache = PG_private_2,
+
+
+ PG_pinned = PG_owner_priv_1,
+ PG_savepinned = PG_dirty,
+
+
+ PG_slob_free = PG_private,
+
+
+ PG_slub_frozen = PG_active,
+ PG_slub_debug = PG_error,
+};
+# 199 "include/linux/page-flags.h"
+struct page;
+
+static inline __attribute__((always_inline)) int PageLocked(struct page *page) { return test_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 PageError(struct page *page) { return 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 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 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 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 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 TestClearPageActive(struct page *page) { return test_and_clear_bit(PG_active, &page->flags); }
+static inline __attribute__((always_inline)) int PageSlab(struct page *page) { return 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 test_bit(PG_checked, &page->flags); } static inline __attribute__((always_inline)) void SetPageChecked(struct page *page) { set_bit(PG_checked, &page->flags); } static inline __attribute__((always_inline)) void ClearPageChecked(struct page *page) { clear_bit(PG_checked, &page->flags); }
+static inline __attribute__((always_inline)) int PagePinned(struct page *page) { return test_bit(PG_pinned, &page->flags); } static inline __attribute__((always_inline)) void SetPagePinned(struct page *page) { set_bit(PG_pinned, &page->flags); } static inline __attribute__((always_inline)) void ClearPagePinned(struct page *page) { clear_bit(PG_pinned, &page->flags); } static inline __attribute__((always_inline)) int TestSetPagePinned(struct page *page) { return test_and_set_bit(PG_pinned, &page->flags); } static inline __attribute__((always_inline)) int TestClearPagePinned(struct page *page) { return test_and_clear_bit(PG_pinned, &page->flags); }
+static inline __attribute__((always_inline)) int PageSavePinned(struct page *page) { return test_bit(PG_savepinned, &page->flags); } static inline __attribute__((always_inline)) void SetPageSavePinned(struct page *page) { set_bit(PG_savepinned, &page->flags); } static inline __attribute__((always_inline)) void ClearPageSavePinned(struct page *page) { clear_bit(PG_savepinned, &page->flags); };
+static inline __attribute__((always_inline)) int PageReserved(struct page *page) { return 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 PageSwapBacked(struct page *page) { return test_bit(PG_swapbacked, &page->flags); } static inline __attribute__((always_inline)) void SetPageSwapBacked(struct page *page) { set_bit(PG_swapbacked, &page->flags); } static inline __attribute__((always_inline)) void ClearPageSwapBacked(struct page *page) { clear_bit(PG_swapbacked, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageSwapBacked(struct page *page) { __clear_bit(PG_swapbacked, &page->flags); }
+
+static inline __attribute__((always_inline)) int PageSlobFree(struct page *page) { return test_bit(PG_slob_free, &page->flags); } static inline __attribute__((always_inline)) void __SetPageSlobFree(struct page *page) { __set_bit(PG_slob_free, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageSlobFree(struct page *page) { __clear_bit(PG_slob_free, &page->flags); }
+
+static inline __attribute__((always_inline)) int PageSlubFrozen(struct page *page) { return test_bit(PG_slub_frozen, &page->flags); } static inline __attribute__((always_inline)) void __SetPageSlubFrozen(struct page *page) { __set_bit(PG_slub_frozen, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageSlubFrozen(struct page *page) { __clear_bit(PG_slub_frozen, &page->flags); }
+static inline __attribute__((always_inline)) int PageSlubDebug(struct page *page) { return test_bit(PG_slub_debug, &page->flags); } static inline __attribute__((always_inline)) void __SetPageSlubDebug(struct page *page) { __set_bit(PG_slub_debug, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageSlubDebug(struct page *page) { __clear_bit(PG_slub_debug, &page->flags); }
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int PagePrivate(struct page *page) { return 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 __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)) int PagePrivate2(struct page *page) { return test_bit(PG_private_2, &page->flags); } static inline __attribute__((always_inline)) void SetPagePrivate2(struct page *page) { set_bit(PG_private_2, &page->flags); } static inline __attribute__((always_inline)) void ClearPagePrivate2(struct page *page) { clear_bit(PG_private_2, &page->flags); } static inline __attribute__((always_inline)) int TestSetPagePrivate2(struct page *page) { return test_and_set_bit(PG_private_2, &page->flags); } static inline __attribute__((always_inline)) int TestClearPagePrivate2(struct page *page) { return test_and_clear_bit(PG_private_2, &page->flags); }
+static inline __attribute__((always_inline)) int PageOwnerPriv1(struct page *page) { return test_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) void SetPageOwnerPriv1(struct page *page) { set_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) void ClearPageOwnerPriv1(struct page *page) { clear_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) int TestClearPageOwnerPriv1(struct page *page) { return test_and_clear_bit(PG_owner_priv_1, &page->flags); }
+
+
+
+
+
+static inline __attribute__((always_inline)) int PageWriteback(struct page *page) { return 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 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 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 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 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); }
+# 249 "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 0; }
+ static inline __attribute__((always_inline)) void SetPageSwapCache(struct page *page) { } static inline __attribute__((always_inline)) void ClearPageSwapCache(struct page *page) { }
+
+
+static inline __attribute__((always_inline)) int PageUnevictable(struct page *page) { return test_bit(PG_unevictable, &page->flags); } static inline __attribute__((always_inline)) void SetPageUnevictable(struct page *page) { set_bit(PG_unevictable, &page->flags); } static inline __attribute__((always_inline)) void ClearPageUnevictable(struct page *page) { clear_bit(PG_unevictable, &page->flags); } static inline __attribute__((always_inline)) void __ClearPageUnevictable(struct page *page) { __clear_bit(PG_unevictable, &page->flags); }
+ static inline __attribute__((always_inline)) int TestClearPageUnevictable(struct page *page) { return test_and_clear_bit(PG_unevictable, &page->flags); }
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int PageMlocked(struct page *page) { return 0; } static inline __attribute__((always_inline)) void SetPageMlocked(struct page *page) { }
+ static inline __attribute__((always_inline)) int TestClearPageMlocked(struct page *page) { return 0; } static inline __attribute__((always_inline)) int __TestClearPageMlocked(struct page *page) { return 0; }
+
+
+
+
+
+static inline __attribute__((always_inline)) int PageUncached(struct page *page) { return 0; }
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int PageHWPoison(struct page *page) { return 0; }
+
+
+
+static inline __attribute__((always_inline)) int PageUptodate(struct page *page)
+{
+ int ret = test_bit(PG_uptodate, &(page)->flags);
+# 299 "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)
+{
+# 325 "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);
+}
+# 349 "include/linux/page-flags.h"
+static inline __attribute__((always_inline)) int PageHead(struct page *page) { return 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 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));
+
+}
+# 429 "include/linux/page-flags.h"
+static inline __attribute__((always_inline)) int page_has_private(struct page *page)
+{
+ return !!(page->flags & (1 << PG_private | 1 << PG_private_2));
+}
+# 236 "include/linux/mm.h" 2
+# 253 "include/linux/mm.h"
+static inline __attribute__((always_inline)) int put_page_testzero(struct page *page)
+{
+ do { } while (0);
+ return (atomic_sub_return(1, (&page->_count)) == 0);
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) int get_page_unless_zero(struct page *page)
+{
+ return ({ int c, old; c = (((&page->_count))->counter); while (c != (0) && (old = (((__typeof__(*((&((((&page->_count)))->counter)))))__cmpxchg_local_generic(((&((((&page->_count)))->counter))), (unsigned long)(((c))), (unsigned long)(((c + (1)))), sizeof(*((&((((&page->_count)))->counter)))))))) != c) c = old; c != (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)
+{
+
+
+
+
+
+ return 0;
+
+}
+
+
+
+static inline __attribute__((always_inline)) int is_vmalloc_or_module_addr(const void *x)
+{
+ return 0;
+}
+
+
+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 + (((unsigned long)(x)-(0)) >> 12));
+ 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;
+}
+# 511 "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) - 2) * (2 != 0))) & ((1UL << 2) - 1);
+}
+# 524 "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) - 2))? (((sizeof(unsigned long)*8) - 0) - 0) : ((((sizeof(unsigned long)*8) - 0) - 0) - 2)) * ((0 + 2) != 0))) & ((1UL << (0 + 2)) - 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)];
+}
+# 559 "include/linux/mm.h"
+static inline __attribute__((always_inline)) void set_page_zone(struct page *page, enum zone_type zone)
+{
+ page->flags &= ~(((1UL << 2) - 1) << (((((sizeof(unsigned long)*8) - 0) - 0) - 2) * (2 != 0)));
+ page->flags |= (zone & ((1UL << 2) - 1)) << (((((sizeof(unsigned long)*8) - 0) - 0) - 2) * (2 != 0));
+}
+
+static inline __attribute__((always_inline)) void set_page_node(struct page *page, unsigned long node)
+{
+ page->flags &= ~(((1UL << 0) - 1) << ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0)));
+ page->flags |= (node & ((1UL << 0) - 1)) << ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0));
+}
+
+static inline __attribute__((always_inline)) void set_page_section(struct page *page, unsigned long section)
+{
+ page->flags &= ~(((1UL << 0) - 1) << (((sizeof(unsigned long)*8) - 0) * (0 != 0)));
+ page->flags |= (section & ((1UL << 0) - 1)) << (((sizeof(unsigned long)*8) - 0) * (0 != 0));
+}
+
+static inline __attribute__((always_inline)) void set_page_links(struct page *page, enum zone_type zone,
+ unsigned long node, unsigned long pfn)
+{
+ set_page_zone(page, zone);
+ set_page_node(page, node);
+ set_page_section(page, ((pfn) >> 0));
+}
+
+
+
+
+# 1 "include/linux/vmstat.h" 1
+
+
+
+
+
+# 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_DMA, PGALLOC_NORMAL , PGALLOC_MOVABLE,
+  PGFREE, PGACTIVATE, PGDEACTIVATE,
+  PGFAULT, PGMAJFAULT,
+  PGREFILL_DMA, PGREFILL_NORMAL , PGREFILL_MOVABLE,
+  PGSTEAL_DMA, PGSTEAL_NORMAL , PGSTEAL_MOVABLE,
+  PGSCAN_KSWAPD_DMA, PGSCAN_KSWAPD_NORMAL , PGSCAN_KSWAPD_MOVABLE,
+  PGSCAN_DIRECT_DMA, PGSCAN_DIRECT_NORMAL , PGSCAN_DIRECT_MOVABLE,
+
+
+
+  PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
+  PAGEOUTRUN, ALLOCSTALL, PGROTATED,
+
+
+
+  UNEVICTABLE_PGCULLED,
+  UNEVICTABLE_PGSCANNED,
+  UNEVICTABLE_PGRESCUED,
+  UNEVICTABLE_PGMLOCKED,
+  UNEVICTABLE_PGMUNLOCKED,
+  UNEVICTABLE_PGCLEARED,
+  UNEVICTABLE_PGSTRANDED,
+  UNEVICTABLE_MLOCKFREED,
+  NR_VM_EVENT_ITEMS
+};
+
+extern int sysctl_stat_interval;
+# 71 "include/linux/vmstat.h"
+struct vm_event_state {
+ unsigned long event[NR_VM_EVENT_ITEMS];
+};
+
+extern __attribute__((section(".discard"), unused)) char __pcpu_scope_vm_event_states; extern __attribute__((section(".data" ""))) __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 *);
+
+
+
+static inline __attribute__((always_inline)) void vm_events_fold_cpu(int cpu)
+{
+}
+# 139 "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;
+}
+
+extern unsigned long global_reclaimable_pages(void);
+extern unsigned long zone_reclaimable_pages(struct zone *zone);
+# 209 "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);
+# 237 "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);
+}
+# 275 "include/linux/vmstat.h"
+static inline __attribute__((always_inline)) void refresh_cpu_vm_stats(int cpu) { }
+# 589 "include/linux/mm.h" 2
+
+static inline __attribute__((always_inline)) __attribute__((always_inline)) void *lowmem_page_address(struct page *page)
+{
+ return ((void *)((unsigned long)(((unsigned long)((page) - mem_map) + (0UL)) << 12) + (0)));
+}
+# 631 "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(!!((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;
+}
+# 708 "include/linux/mm.h"
+extern void pagefault_out_of_memory(void);
+
+
+
+extern void show_free_areas(void);
+
+int shmem_lock(struct file *file, int lock, struct user_struct *user);
+struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags);
+int shmem_zero_setup(struct vm_area_struct *);
+
+
+extern unsigned long shmem_get_unmapped_area(struct file *file,
+          unsigned long addr,
+          unsigned long len,
+          unsigned long pgoff,
+          unsigned long flags);
+
+
+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);
+
+int zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
+  unsigned long size);
+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 *);
+# 764 "include/linux/mm.h"
+struct mm_walk {
+ int (*pgd_entry)(pgd_t *, unsigned long, unsigned long, struct mm_walk *);
+ int (*pud_entry)(pgd_t *, unsigned long, unsigned long, struct mm_walk *);
+ int (*pmd_entry)(pmd_t *, unsigned long, unsigned long, struct mm_walk *);
+ int (*pte_entry)(pte_t *, unsigned long, unsigned long, struct mm_walk *);
+ int (*pte_hole)(unsigned long, unsigned long, struct mm_walk *);
+ struct mm_struct *mm;
+ void *private;
+};
+
+int walk_page_range(unsigned long addr, unsigned long end,
+  struct mm_walk *walk);
+void free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
+  unsigned long end, 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);
+int follow_pfn(struct vm_area_struct *vma, unsigned long address,
+ unsigned long *pfn);
+int follow_phys(struct vm_area_struct *vma, unsigned long address,
+  unsigned int flags, unsigned long *prot, resource_size_t *phys);
+int generic_access_phys(struct vm_area_struct *vma, unsigned long addr,
+   void *buf, int len, int write);
+
+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 void truncate_pagecache(struct inode *inode, loff_t old, loff_t new);
+extern int vmtruncate(struct inode *inode, loff_t offset);
+extern int vmtruncate_range(struct inode *inode, loff_t offset, loff_t end);
+
+int truncate_inode_page(struct address_space *mapping, struct page *page);
+int generic_error_remove_page(struct address_space *mapping, struct page *page);
+
+int invalidate_inode_page(struct page *page);
+
+
+
+
+
+static inline __attribute__((always_inline)) int handle_mm_fault(struct mm_struct *mm,
+   struct vm_area_struct *vma, unsigned long address,
+   unsigned int flags)
+{
+
+ do { asm volatile( "1:        .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/mm.h"), "i"(813), "i"(0), "i"(sizeof(struct bug_entry))); for (;;); } while (0);
+ return 0x0002;
+}
+
+
+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 nr_pages, int write, int force,
+   struct page **pages, struct vm_area_struct **vmas);
+int get_user_pages_fast(unsigned long start, int nr_pages, int write,
+   struct page **pages);
+struct page *get_dump_page(unsigned long addr);
+
+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);
+void account_page_dirtied(struct page *page, struct address_space *mapping);
+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);
+
+
+
+
+int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
+     struct page **pages);
+# 871 "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;
+}
+# 904 "include/linux/mm.h"
+int __pmd_alloc(struct mm_struct *mm, pgd_t *pud, unsigned long address);
+
+
+int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
+int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);
+# 950 "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);
+}
+# 988 "include/linux/mm.h"
+extern void free_area_init(unsigned long * zones_size);
+extern void free_area_init_node(int nid, unsigned long * zones_size,
+  unsigned long zone_start_pfn, unsigned long *zholes_size);
+# 1039 "include/linux/mm.h"
+static inline __attribute__((always_inline)) int __early_pfn_to_nid(unsigned long pfn)
+{
+ return 0;
+}
+# 1052 "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_wmarks(void);
+extern void calculate_zone_inactive_ratio(struct zone *zone);
+extern void mem_init(void);
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) mmap_init(void);
+extern void show_mem(void);
+extern void si_meminfo(struct sysinfo * val);
+extern void si_meminfo_node(struct sysinfo *val, int nid);
+extern int after_bootmem;
+
+
+
+
+static inline __attribute__((always_inline)) void setup_per_cpu_pageset(void) {}
+
+
+extern void zone_pcp_update(struct zone *zone);
+
+
+extern atomic_long_t mmap_pages_allocated;
+
+
+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 int mm_take_all_locks(struct mm_struct *mm);
+extern void mm_drop_all_locks(struct mm_struct *mm);
+
+
+
+extern void added_exe_file_vma(struct mm_struct *mm);
+extern void removed_exe_file_vma(struct mm_struct *mm);
+# 1127 "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);
+
+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)+((typeof(len))((1UL << 12))-1))&~((typeof(len))((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);
+void task_dirty_inc(struct task_struct *tsk);
+
+
+
+
+
+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);
+unsigned long ra_submit(struct file_ra_state *ra,
+   struct address_space *mapping,
+   struct file *filp);
+
+
+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);
+# 1258 "include/linux/mm.h"
+extern int debug_pagealloc_enabled;
+
+extern void kernel_map_pages(struct page *page, int numpages, int enable);
+
+static inline __attribute__((always_inline)) void enable_debug_pagealloc(void)
+{
+ debug_pagealloc_enabled = 1;
+}
+# 1280 "include/linux/mm.h"
+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,
+     void *, size_t *, loff_t *);
+unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
+   unsigned long lru_pages);
+void drop_pagecache(void);
+
+
+
+
+
+
+
+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);
+pgd_t *vmemmap_pud_populate(pgd_t *pgd, unsigned long addr, int node);
+pmd_t *vmemmap_pmd_populate(pgd_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);
+
+extern int account_locked_memory(struct mm_struct *mm, struct rlimit *rlim,
+     size_t size);
+extern void refund_locked_memory(struct mm_struct *mm, size_t size);
+
+extern void memory_failure(unsigned long pfn, int trapno);
+extern int __memory_failure(unsigned long pfn, int trapno, int ref);
+extern int sysctl_memory_failure_early_kill;
+extern int sysctl_memory_failure_recovery;
+extern atomic_long_t mce_bad_pages;
+# 8 "include/linux/pagemap.h" 2
+
+
+# 1 "include/linux/highmem.h" 1
+
+
+
+
+
+# 1 "include/linux/uaccess.h" 1
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+# 1 "include/linux/sched.h" 1
+# 46 "include/linux/sched.h"
+struct sched_param {
+ int sched_priority;
+};
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/param.h" 1
+# 51 "include/linux/sched.h" 2
+# 68 "include/linux/sched.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cputime.h" 1
+# 1 "include/asm-generic/cputime.h" 1
+
+
+
+
+
+
+typedef unsigned long cputime_t;
+# 25 "include/asm-generic/cputime.h"
+typedef u64 cputime64_t;
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cputime.h" 2
+# 69 "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 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ipcbuf.h" 1
+# 1 "include/asm-generic/ipcbuf.h" 1
+# 19 "include/asm-generic/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 char __pad1[4 - sizeof(__kernel_mode_t)];
+ unsigned short seq;
+ unsigned short __pad2;
+ unsigned long __unused1;
+ unsigned long __unused2;
+};
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/ipcbuf.h" 2
+# 22 "include/linux/ipc.h" 2
+# 57 "include/linux/ipc.h"
+struct ipc_kludge {
+ struct msgbuf *msgp;
+ long msgtyp;
+};
+# 86 "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 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/sembuf.h" 1
+# 1 "include/asm-generic/sembuf.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/bitsperlong.h" 1
+# 5 "include/asm-generic/sembuf.h" 2
+# 23 "include/asm-generic/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;
+};
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/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;
+};
+# 83 "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 list_head sem_pending;
+ struct list_head list_id;
+ unsigned long sem_nsems;
+};
+
+
+struct sem_queue {
+ struct list_head list;
+ struct task_struct *sleeper;
+ struct sem_undo *undo;
+ int pid;
+ int status;
+ struct sembuf *sops;
+ int nsops;
+ int alter;
+};
+
+
+
+
+struct sem_undo {
+ struct list_head list_proc;
+
+ struct rcu_head rcu;
+ struct sem_undo_list *ulp;
+ struct list_head list_id;
+ int semid;
+ short * semadj;
+};
+
+
+
+
+struct sem_undo_list {
+ atomic_t refcnt;
+ spinlock_t lock;
+ struct list_head list_proc;
+};
+
+struct sysv_sem {
+ struct sem_undo_list *undo_list;
+};
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int copy_semundo(unsigned long clone_flags, struct task_struct *tsk)
+{
+ return 0;
+}
+
+static inline __attribute__((always_inline)) void exit_sem(struct task_struct *tsk)
+{
+ return;
+}
+# 72 "include/linux/sched.h" 2
+# 1 "include/linux/signal.h" 1
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/signal.h" 1
+
+
+
+
+# 1 "include/asm-generic/signal.h" 1
+# 93 "include/asm-generic/signal.h"
+typedef struct {
+ unsigned long sig[(64 / 32)];
+} sigset_t;
+
+
+typedef unsigned long old_sigset_t;
+
+# 1 "include/asm-generic/signal-defs.h" 1
+# 17 "include/asm-generic/signal-defs.h"
+typedef void __signalfn_t(int);
+typedef __signalfn_t *__sighandler_t;
+
+typedef void __restorefn_t(void);
+typedef __restorefn_t *__sigrestore_t;
+# 101 "include/asm-generic/signal.h" 2
+
+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 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/sigcontext.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/sigcontext.h"
+struct sigcontext {
+ unsigned long sc_r0;
+ unsigned long sc_r1;
+ unsigned long sc_r2;
+ unsigned long sc_r3;
+ unsigned long sc_r4;
+ unsigned long sc_r5;
+ unsigned long sc_r6;
+ unsigned long sc_r7;
+ unsigned long sc_p0;
+ unsigned long sc_p1;
+ unsigned long sc_p2;
+ unsigned long sc_p3;
+ unsigned long sc_p4;
+ unsigned long sc_p5;
+ unsigned long sc_usp;
+ unsigned long sc_a0w;
+ unsigned long sc_a1w;
+ unsigned long sc_a0x;
+ unsigned long sc_a1x;
+ unsigned long sc_astat;
+ unsigned long sc_rets;
+ unsigned long sc_pc;
+ unsigned long sc_retx;
+ unsigned long sc_fp;
+ unsigned long sc_i0;
+ unsigned long sc_i1;
+ unsigned long sc_i2;
+ unsigned long sc_i3;
+ unsigned long sc_m0;
+ unsigned long sc_m1;
+ unsigned long sc_m2;
+ unsigned long sc_m3;
+ unsigned long sc_l0;
+ unsigned long sc_l1;
+ unsigned long sc_l2;
+ unsigned long sc_l3;
+ unsigned long sc_b0;
+ unsigned long sc_b1;
+ unsigned long sc_b2;
+ unsigned long sc_b3;
+ unsigned long sc_lc0;
+ unsigned long sc_lc1;
+ unsigned long sc_lt0;
+ unsigned long sc_lt1;
+ unsigned long sc_lb0;
+ unsigned long sc_lb1;
+ unsigned long sc_seqstat;
+};
+# 124 "include/asm-generic/signal.h" 2
+# 6 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/signal.h" 2
+# 5 "include/linux/signal.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/siginfo.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/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 - (3 * sizeof(int))) / sizeof(int))];
+
+
+  struct {
+   __kernel_pid_t _pid;
+   __kernel_uid32_t _uid;
+  } _kill;
+
+
+  struct {
+   __kernel_timer_t _tid;
+   int _overrun;
+   char _pad[sizeof( __kernel_uid32_t) - sizeof(int)];
+   sigval_t _sigval;
+   int _sys_private;
+  } _timer;
+
+
+  struct {
+   __kernel_pid_t _pid;
+   __kernel_uid32_t _uid;
+   sigval_t _sigval;
+  } _rt;
+
+
+  struct {
+   __kernel_pid_t _pid;
+   __kernel_uid32_t _uid;
+   int _status;
+   __kernel_clock_t _utime;
+   __kernel_clock_t _stime;
+  } _sigchld;
+
+
+  struct {
+   void *_addr;
+
+
+
+   short _addr_lsb;
+  } _sigfault;
+
+
+  struct {
+   long _band;
+   int _fd;
+  } _sigpoll;
+ } _sifields;
+} siginfo_t;
+# 259 "include/asm-generic/siginfo.h"
+typedef struct sigevent {
+ sigval_t sigev_value;
+ int sigev_signo;
+ int sigev_notify;
+ union {
+  int _pad[((64 - (sizeof(int) * 2 + sizeof(sigval_t))) / sizeof(int))];
+   int _tid;
+
+  struct {
+   void (*_function)(sigval_t);
+   void *_attribute;
+  } _sigev_thread;
+ } _sigev_un;
+} sigevent_t;
+
+
+
+
+
+
+
+struct siginfo;
+void do_schedule_next_timer(struct siginfo *info);
+
+
+
+
+
+static inline __attribute__((always_inline)) void copy_siginfo(struct siginfo *to, struct siginfo *from)
+{
+ if (from->si_code < 0)
+  memcpy(to, from, sizeof(*to));
+ else
+
+  memcpy(to, from, (3 * sizeof(int)) + sizeof(from->_sifields._sigchld));
+}
+
+
+
+extern int copy_siginfo_to_user(struct siginfo *to, struct siginfo *from);
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/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 / 32) == 1)
+  set->sig[0] |= 1UL << sig;
+ else
+  set->sig[sig / 32] |= 1UL << (sig % 32);
+}
+
+static inline __attribute__((always_inline)) void sigdelset(sigset_t *set, int _sig)
+{
+ unsigned long sig = _sig - 1;
+ if ((64 / 32) == 1)
+  set->sig[0] &= ~(1UL << sig);
+ else
+  set->sig[sig / 32] &= ~(1UL << (sig % 32));
+}
+
+static inline __attribute__((always_inline)) int sigismember(sigset_t *set, int _sig)
+{
+ unsigned long sig = _sig - 1;
+ if ((64 / 32) == 1)
+  return 1 & (set->sig[0] >> sig);
+ else
+  return 1 & (set->sig[sig / 32] >> (sig % 32));
+}
+
+static inline __attribute__((always_inline)) int sigfindinword(unsigned long word)
+{
+ return __ffs(~(~word));
+}
+
+
+
+static inline __attribute__((always_inline)) int sigisemptyset(sigset_t *set)
+{
+ extern void _NSIG_WORDS_is_unsupported_size(void);
+ switch ((64 / 32)) {
+ case 4:
+  return (set->sig[3] | set->sig[2] |
+   set->sig[1] | set->sig[0]) == 0;
+ case 2:
+  return (set->sig[1] | set->sig[0]) == 0;
+ case 1:
+  return set->sig[0] == 0;
+ default:
+  _NSIG_WORDS_is_unsupported_size();
+  return 0;
+ }
+}
+# 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 / 32)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) | (b3)); r->sig[2] = ((a2) | (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) | (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) | (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
+
+
+static inline __attribute__((always_inline)) void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 32)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & (b3)); r->sig[2] = ((a2) & (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
+
+
+static inline __attribute__((always_inline)) void signandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 32)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & ~(b3)); r->sig[2] = ((a2) & ~(b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & ~(b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & ~(b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
+# 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 / 32)) { case 4: set->sig[3] = (~(set->sig[3])); set->sig[2] = (~(set->sig[2])); case 2: set->sig[1] = (~(set->sig[1])); case 1: set->sig[0] = (~(set->sig[0])); break; default: _NSIG_WORDS_is_unsupported_size(); } }
+
+
+
+
+static inline __attribute__((always_inline)) void sigemptyset(sigset_t *set)
+{
+ switch ((64 / 32)) {
+ default:
+  memset(set, 0, sizeof(sigset_t));
+  break;
+ case 2: set->sig[1] = 0;
+ case 1: set->sig[0] = 0;
+  break;
+ }
+}
+
+static inline __attribute__((always_inline)) void sigfillset(sigset_t *set)
+{
+ switch ((64 / 32)) {
+ default:
+  memset(set, -1, sizeof(sigset_t));
+  break;
+ case 2: set->sig[1] = -1;
+ case 1: set->sig[0] = -1;
+  break;
+ }
+}
+
+
+
+static inline __attribute__((always_inline)) void sigaddsetmask(sigset_t *set, unsigned long mask)
+{
+ set->sig[0] |= mask;
+}
+
+static inline __attribute__((always_inline)) void sigdelsetmask(sigset_t *set, unsigned long mask)
+{
+ set->sig[0] &= ~mask;
+}
+
+static inline __attribute__((always_inline)) int sigtestsetmask(sigset_t *set, unsigned long mask)
+{
+ return (set->sig[0] & mask) != 0;
+}
+
+static inline __attribute__((always_inline)) void siginitset(sigset_t *set, unsigned long mask)
+{
+ set->sig[0] = mask;
+ switch ((64 / 32)) {
+ default:
+  memset(&set->sig[1], 0, sizeof(long)*((64 / 32)-1));
+  break;
+ case 2: set->sig[1] = 0;
+ case 1: ;
+ }
+}
+
+static inline __attribute__((always_inline)) void siginitsetinv(sigset_t *set, unsigned long mask)
+{
+ set->sig[0] = ~mask;
+ switch ((64 / 32)) {
+ default:
+  memset(&set->sig[1], -1, sizeof(long)*((64 / 32)-1));
+  break;
+ case 2: set->sig[1] = -1;
+ case 1: ;
+ }
+}
+
+
+
+static inline __attribute__((always_inline)) void init_sigpending(struct sigpending *sig)
+{
+ sigemptyset(&sig->signal);
+ INIT_LIST_HEAD(&sig->list);
+}
+
+extern void flush_sigqueue(struct sigpending *queue);
+
+
+static inline __attribute__((always_inline)) int valid_signal(unsigned long sig)
+{
+ return sig <= 64 ? 1 : 0;
+}
+
+extern int next_signal(struct sigpending *pending, sigset_t *mask);
+extern int do_send_sig_info(int sig, struct siginfo *info,
+    struct task_struct *p, bool group);
+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_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig,
+     siginfo_t *info);
+extern long do_sigpending(void *, unsigned long);
+extern int 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);
+# 377 "include/linux/signal.h"
+void signals_init(void);
+# 73 "include/linux/sched.h" 2
+
+
+
+
+
+
+# 1 "include/linux/proportions.h" 1
+# 12 "include/linux/proportions.h"
+# 1 "include/linux/percpu_counter.h" 1
+# 82 "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 { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ __prop_inc_percpu(pd, pl);
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(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;
+
+
+
+
+
+ unsigned long period;
+ int shift;
+ 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 { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
+ __prop_inc_single(pd, pl);
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); if ((((flags) & ~0x3f) == 0)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
+}
+# 80 "include/linux/sched.h" 2
+# 1 "include/linux/seccomp.h" 1
+# 26 "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;
+}
+# 81 "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;
+};
+# 130 "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);
+# 198 "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);
+}
+# 237 "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);
+# 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 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/resource.h" 1
+# 1 "include/asm-generic/resource.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/resource.h" 2
+# 72 "include/linux/resource.h" 2
+
+int getrusage(struct task_struct *p, int who, struct rusage *ru);
+# 88 "include/linux/sched.h" 2
+
+# 1 "include/linux/hrtimer.h" 1
+# 27 "include/linux/hrtimer.h"
+struct hrtimer_clock_base;
+struct hrtimer_cpu_base;
+
+
+
+
+enum hrtimer_mode {
+ HRTIMER_MODE_ABS = 0x0,
+ HRTIMER_MODE_REL = 0x1,
+ HRTIMER_MODE_PINNED = 0x02,
+ HRTIMER_MODE_ABS_PINNED = 0x02,
+ HRTIMER_MODE_REL_PINNED = 0x03,
+};
+
+
+
+
+enum hrtimer_restart {
+ HRTIMER_NORESTART,
+ HRTIMER_RESTART,
+};
+# 103 "include/linux/hrtimer.h"
+struct hrtimer {
+ struct rb_node node;
+ ktime_t _expires;
+ ktime_t _softexpires;
+ enum hrtimer_restart (*function)(struct hrtimer *);
+ struct hrtimer_clock_base *base;
+ unsigned long state;
+
+ int start_pid;
+ void *start_site;
+ char start_comm[16];
+
+};
+# 124 "include/linux/hrtimer.h"
+struct hrtimer_sleeper {
+ struct hrtimer timer;
+ struct task_struct *task;
+};
+# 141 "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 softirq_time;
+
+ ktime_t offset;
+
+};
+# 170 "include/linux/hrtimer.h"
+struct hrtimer_cpu_base {
+ spinlock_t lock;
+ struct hrtimer_clock_base clock_base[2];
+
+ ktime_t expires_next;
+ int hres_active;
+ unsigned long nr_events;
+
+};
+
+static inline __attribute__((always_inline)) void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
+{
+ timer->_expires = time;
+ timer->_softexpires = time;
+}
+
+static inline __attribute__((always_inline)) void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
+{
+ timer->_softexpires = time;
+ timer->_expires = ktime_add_safe(time, delta);
+}
+
+static inline __attribute__((always_inline)) void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, unsigned long delta)
+{
+ timer->_softexpires = time;
+ timer->_expires = ktime_add_safe(time, ns_to_ktime(delta));
+}
+
+static inline __attribute__((always_inline)) void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
+{
+ timer->_expires.tv64 = tv64;
+ timer->_softexpires.tv64 = tv64;
+}
+
+static inline __attribute__((always_inline)) void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
+{
+ timer->_expires = ktime_add_safe(timer->_expires, time);
+ timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
+}
+
+static inline __attribute__((always_inline)) void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
+{
+ timer->_expires = ktime_add_ns(timer->_expires, ns);
+ timer->_softexpires = ktime_add_ns(timer->_softexpires, ns);
+}
+
+static inline __attribute__((always_inline)) ktime_t hrtimer_get_expires(const struct hrtimer *timer)
+{
+ return timer->_expires;
+}
+
+static inline __attribute__((always_inline)) ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
+{
+ return timer->_softexpires;
+}
+
+static inline __attribute__((always_inline)) s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
+{
+ return timer->_expires.tv64;
+}
+static inline __attribute__((always_inline)) s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
+{
+ return timer->_softexpires.tv64;
+}
+
+static inline __attribute__((always_inline)) s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
+{
+ return ktime_to_ns(timer->_expires);
+}
+
+static inline __attribute__((always_inline)) ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
+{
+    return ktime_sub(timer->_expires, timer->base->get_time());
+}
+
+
+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;
+}
+
+extern void hrtimer_peek_ahead_timers(void);
+# 308 "include/linux/hrtimer.h"
+extern ktime_t ktime_get(void);
+extern ktime_t ktime_get_real(void);
+
+
+extern __attribute__((section(".discard"), unused)) char __pcpu_scope_tick_cpu_device; extern __attribute__((section(".data" ""))) __typeof__(struct tick_device) per_cpu__tick_cpu_device;
+
+
+
+
+
+extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
+    enum hrtimer_mode mode);
+
+
+extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,
+      enum hrtimer_mode mode);
+
+extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
+# 337 "include/linux/hrtimer.h"
+extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
+    const enum hrtimer_mode mode);
+extern int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
+   unsigned long range_ns, const enum hrtimer_mode mode);
+extern int
+__hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
+    unsigned long delta_ns,
+    const enum hrtimer_mode mode, int wakeup);
+
+extern int hrtimer_cancel(struct hrtimer *timer);
+extern int hrtimer_try_to_cancel(struct hrtimer *timer);
+
+static inline __attribute__((always_inline)) int hrtimer_start_expires(struct hrtimer *timer,
+      enum hrtimer_mode mode)
+{
+ unsigned long delta;
+ ktime_t soft, hard;
+ soft = hrtimer_get_softexpires(timer);
+ hard = hrtimer_get_expires(timer);
+ delta = ktime_to_ns(ktime_sub(hard, soft));
+ return hrtimer_start_range_ns(timer, soft, delta, mode);
+}
+
+static inline __attribute__((always_inline)) int hrtimer_restart(struct hrtimer *timer)
+{
+ return hrtimer_start_expires(timer, 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;
+}
+
+
+
+
+
+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 int schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
+      const enum hrtimer_mode mode);
+extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
+
+
+extern void hrtimer_run_queues(void);
+extern void hrtimer_run_pending(void);
+
+
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) hrtimers_init(void);
+
+
+extern u64 ktime_divns(const ktime_t kt, s64 div);
+
+
+
+
+
+extern void sysrq_timer_list_show(void);
+
+
+
+
+
+
+extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
+         void *timerf, char *comm,
+         unsigned int timer_flag);
+
+static inline __attribute__((always_inline)) void timer_stats_account_hrtimer(struct hrtimer *timer)
+{
+ if (__builtin_expect(!!(!timer->start_site), 1))
+  return;
+ timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
+     timer->function, timer->start_comm, 0);
+}
+
+extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer,
+       void *addr);
+
+static inline __attribute__((always_inline)) void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
+{
+ if (__builtin_expect(!!(!timer_stats_active), 1))
+  return;
+ __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0));
+}
+
+static inline __attribute__((always_inline)) void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
+{
+ timer->start_site = ((void *)0);
+}
+# 90 "include/linux/sched.h" 2
+# 1 "include/linux/task_io_accounting.h" 1
+# 11 "include/linux/task_io_accounting.h"
+struct task_io_accounting {
+# 45 "include/linux/task_io_accounting.h"
+};
+# 91 "include/linux/sched.h" 2
+
+# 1 "include/linux/latencytop.h" 1
+# 41 "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)
+{
+}
+# 93 "include/linux/sched.h" 2
+# 1 "include/linux/cred.h" 1
+# 17 "include/linux/cred.h"
+# 1 "include/linux/key.h" 1
+# 22 "include/linux/key.h"
+# 1 "include/linux/sysctl.h" 1
+# 32 "include/linux/sysctl.h"
+struct completion;
+
+
+
+
+
+
+struct __sysctl_args {
+ int *name;
+ int nlen;
+ void *oldval;
+ size_t *oldlenp;
+ void *newval;
+ size_t newlen;
+ unsigned long __unused[4];
+};
+# 59 "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_ARP_NOTIFY=22,
+ __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;
+
+struct ctl_table_set {
+ struct list_head list;
+ struct ctl_table_set *parent;
+ int (*is_seen)(struct ctl_table_set *);
+};
+
+extern void setup_sysctl_set(struct ctl_table_set *p,
+ struct ctl_table_set *parent,
+ int (*is_seen)(struct ctl_table_set *));
+
+struct ctl_table_header;
+
+extern void sysctl_head_get(struct ctl_table_header *);
+extern void sysctl_head_put(struct ctl_table_header *);
+extern int sysctl_is_seen(struct ctl_table_header *);
+extern struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *);
+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,
+    void *oldval, size_t *oldlenp,
+    void *newval, size_t newlen);
+
+typedef int proc_handler (struct ctl_table *ctl, int write,
+     void *buffer, size_t *lenp, loff_t *ppos);
+
+extern int proc_dostring(struct ctl_table *, int,
+    void *, size_t *, loff_t *);
+extern int proc_dointvec(struct ctl_table *, int,
+    void *, size_t *, loff_t *);
+extern int proc_dointvec_minmax(struct ctl_table *, int,
+    void *, size_t *, loff_t *);
+extern int proc_dointvec_jiffies(struct ctl_table *, int,
+     void *, size_t *, loff_t *);
+extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int,
+     void *, size_t *, loff_t *);
+extern int proc_dointvec_ms_jiffies(struct ctl_table *, int,
+        void *, size_t *, loff_t *);
+extern int proc_doulongvec_minmax(struct ctl_table *, int,
+      void *, size_t *, loff_t *);
+extern int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int,
+          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;
+# 1051 "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 ctl_table_set default_set;
+ struct ctl_table_set *(*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;
+ int count;
+ struct completion *unregistering;
+ struct ctl_table *ctl_table_arg;
+ struct ctl_table_root *root;
+ struct ctl_table_set *set;
+ struct ctl_table *attached_by;
+ struct ctl_table *attached_to;
+ struct ctl_table_header *parent;
+};
+
+
+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;
+# 74 "include/linux/key.h"
+struct seq_file;
+struct user_struct;
+struct signal_struct;
+struct cred;
+
+struct key_type;
+struct key_owner;
+struct keyring_list;
+struct keyring_name;
+# 98 "include/linux/key.h"
+typedef struct __key_reference_with_attributes *key_ref_t;
+
+static inline __attribute__((always_inline)) key_ref_t make_key_ref(const struct key *key,
+         unsigned long possession)
+{
+ return (key_ref_t) ((unsigned long) key | possession);
+}
+
+static inline __attribute__((always_inline)) struct key *key_ref_to_ptr(const key_ref_t key_ref)
+{
+ return (struct key *) ((unsigned long) key_ref & ~1UL);
+}
+
+static inline __attribute__((always_inline)) unsigned long is_key_possessed(const key_ref_t key_ref)
+{
+ return (unsigned long) key_ref & 1UL;
+}
+# 124 "include/linux/key.h"
+struct key {
+ atomic_t usage;
+ key_serial_t serial;
+ struct rb_node serial_node;
+ struct key_type *type;
+ struct rw_semaphore sem;
+ struct key_user *user;
+ void *security;
+ union {
+  time_t expiry;
+  time_t revoked_at;
+ };
+ uid_t uid;
+ gid_t gid;
+ key_perm_t perm;
+ unsigned short quotalen;
+ unsigned short datalen;
+# 151 "include/linux/key.h"
+ unsigned long flags;
+# 164 "include/linux/key.h"
+ char *description;
+
+
+
+
+ union {
+  struct list_head link;
+  unsigned long x[2];
+  void *p[2];
+ } type_data;
+
+
+
+
+
+ union {
+  unsigned long value;
+  void *data;
+  struct keyring_list *subscriptions;
+ } payload;
+};
+
+extern struct key *key_alloc(struct key_type *type,
+        const char *desc,
+        uid_t uid, gid_t gid,
+        const struct cred *cred,
+        key_perm_t perm,
+        unsigned long flags);
+
+
+
+
+
+
+extern void key_revoke(struct key *key);
+extern void key_put(struct key *key);
+
+static inline __attribute__((always_inline)) struct key *key_get(struct key *key)
+{
+ if (key)
+  atomic_inc(&key->usage);
+ return key;
+}
+
+static inline __attribute__((always_inline)) void key_ref_put(key_ref_t key_ref)
+{
+ key_put(key_ref_to_ptr(key_ref));
+}
+
+extern struct key *request_key(struct key_type *type,
+          const char *description,
+          const char *callout_info);
+
+extern struct key *request_key_with_auxdata(struct key_type *type,
+         const char *description,
+         const void *callout_info,
+         size_t callout_len,
+         void *aux);
+
+extern struct key *request_key_async(struct key_type *type,
+         const char *description,
+         const void *callout_info,
+         size_t callout_len);
+
+extern struct key *request_key_async_with_auxdata(struct key_type *type,
+        const char *description,
+        const void *callout_info,
+        size_t callout_len,
+        void *aux);
+
+extern int wait_for_key_construction(struct key *key, bool intr);
+
+extern int key_validate(struct key *key);
+
+extern key_ref_t key_create_or_update(key_ref_t keyring,
+          const char *type,
+          const char *description,
+          const void *payload,
+          size_t plen,
+          key_perm_t perm,
+          unsigned long flags);
+
+extern int key_update(key_ref_t key,
+        const void *payload,
+        size_t plen);
+
+extern int key_link(struct key *keyring,
+      struct key *key);
+
+extern int key_unlink(struct key *keyring,
+        struct key *key);
+
+extern struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
+     const struct cred *cred,
+     unsigned long flags,
+     struct key *dest);
+
+extern int keyring_clear(struct key *keyring);
+
+extern key_ref_t keyring_search(key_ref_t keyring,
+    struct key_type *type,
+    const char *description);
+
+extern int keyring_add_key(struct key *keyring,
+      struct key *key);
+
+extern struct key *key_lookup(key_serial_t id);
+
+static inline __attribute__((always_inline)) key_serial_t key_serial(struct key *key)
+{
+ return key ? key->serial : 0;
+}
+
+
+extern ctl_table key_sysctls[];
+
+
+extern void key_replace_session_keyring(void);
+
+
+
+
+extern int install_thread_keyring_to_cred(struct cred *cred);
+extern void key_fsuid_changed(struct task_struct *tsk);
+extern void key_fsgid_changed(struct task_struct *tsk);
+extern void key_init(void);
+# 18 "include/linux/cred.h" 2
+# 1 "include/linux/selinux.h" 1
+# 17 "include/linux/selinux.h"
+struct selinux_audit_rule;
+struct audit_context;
+struct kern_ipc_perm;
+# 71 "include/linux/selinux.h"
+static inline __attribute__((always_inline)) int selinux_string_to_sid(const char *str, u32 *sid)
+{
+       *sid = 0;
+       return 0;
+}
+
+static inline __attribute__((always_inline)) int selinux_secmark_relabel_packet_permission(u32 sid)
+{
+ return 0;
+}
+
+static inline __attribute__((always_inline)) void selinux_secmark_refcount_inc(void)
+{
+ return;
+}
+
+static inline __attribute__((always_inline)) void selinux_secmark_refcount_dec(void)
+{
+ return;
+}
+
+static inline __attribute__((always_inline)) bool selinux_is_enabled(void)
+{
+ return false;
+}
+# 19 "include/linux/cred.h" 2
+
+
+struct user_struct;
+struct cred;
+struct inode;
+
+
+
+
+
+
+
+struct group_info {
+ atomic_t usage;
+ int ngroups;
+ int nblocks;
+ gid_t small_block[32];
+ gid_t *blocks[0];
+};
+# 48 "include/linux/cred.h"
+static inline __attribute__((always_inline)) struct group_info *get_group_info(struct group_info *gi)
+{
+ atomic_inc(&gi->usage);
+ return gi;
+}
+# 64 "include/linux/cred.h"
+extern struct group_info *groups_alloc(int);
+extern struct group_info init_groups;
+extern void groups_free(struct group_info *);
+extern int set_current_groups(struct group_info *);
+extern int set_groups(struct cred *, struct group_info *);
+extern int groups_search(const struct group_info *, gid_t);
+
+
+
+
+
+extern int in_group_p(gid_t);
+extern int in_egroup_p(gid_t);
+
+
+
+
+
+
+struct thread_group_cred {
+ atomic_t usage;
+ pid_t tgid;
+ spinlock_t lock;
+ struct key *session_keyring;
+ struct key *process_keyring;
+ struct rcu_head rcu;
+};
+# 116 "include/linux/cred.h"
+struct cred {
+ atomic_t usage;
+
+ atomic_t subscribers;
+ void *put_addr;
+ unsigned magic;
+
+
+
+ uid_t uid;
+ gid_t gid;
+ uid_t suid;
+ gid_t sgid;
+ uid_t euid;
+ gid_t egid;
+ uid_t fsuid;
+ gid_t fsgid;
+ unsigned securebits;
+ kernel_cap_t cap_inheritable;
+ kernel_cap_t cap_permitted;
+ kernel_cap_t cap_effective;
+ kernel_cap_t cap_bset;
+
+ unsigned char jit_keyring;
+
+ struct key *thread_keyring;
+ struct key *request_key_auth;
+ struct thread_group_cred *tgcred;
+
+
+ void *security;
+
+ struct user_struct *user;
+ struct group_info *group_info;
+ struct rcu_head rcu;
+};
+
+extern void __put_cred(struct cred *);
+extern void exit_creds(struct task_struct *);
+extern int copy_creds(struct task_struct *, unsigned long);
+extern struct cred *cred_alloc_blank(void);
+extern struct cred *prepare_creds(void);
+extern struct cred *prepare_exec_creds(void);
+extern struct cred *prepare_usermodehelper_creds(void);
+extern int commit_creds(struct cred *);
+extern void abort_creds(struct cred *);
+extern const struct cred *override_creds(const struct cred *);
+extern void revert_creds(const struct cred *);
+extern struct cred *prepare_kernel_cred(struct task_struct *);
+extern int change_create_files_as(struct cred *, struct inode *);
+extern int set_security_override(struct cred *, u32);
+extern int set_security_override_from_ctx(struct cred *, const char *);
+extern int set_create_files_as(struct cred *, struct inode *);
+extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) cred_init(void);
+
+
+
+
+
+extern void __invalid_creds(const struct cred *, const char *, unsigned);
+extern void __validate_process_creds(struct task_struct *,
+         const char *, unsigned);
+
+extern bool creds_are_invalid(const struct cred *cred);
+
+static inline __attribute__((always_inline)) void __validate_creds(const struct cred *cred,
+        const char *file, unsigned line)
+{
+ if (__builtin_expect(!!(creds_are_invalid(cred)), 0))
+  __invalid_creds(cred, file, line);
+}
+# 198 "include/linux/cred.h"
+extern void validate_creds_for_do_exit(struct task_struct *);
+# 218 "include/linux/cred.h"
+static inline __attribute__((always_inline)) struct cred *get_new_cred(struct cred *cred)
+{
+ atomic_inc(&cred->usage);
+ return cred;
+}
+# 237 "include/linux/cred.h"
+static inline __attribute__((always_inline)) const struct cred *get_cred(const struct cred *cred)
+{
+ struct cred *nonconst_cred = (struct cred *) cred;
+ do { __validate_creds((cred), "include/linux/cred.h", 240); } while(0);
+ return get_new_cred(nonconst_cred);
+}
+# 255 "include/linux/cred.h"
+static inline __attribute__((always_inline)) void put_cred(const struct cred *_cred)
+{
+ struct cred *cred = (struct cred *) _cred;
+
+ do { __validate_creds((cred), "include/linux/cred.h", 259); } while(0);
+ if ((atomic_sub_return(1, (&(cred)->usage)) == 0))
+  __put_cred(cred);
+}
+# 94 "include/linux/sched.h" 2
+
+
+
+struct exec_domain;
+struct futex_pi_state;
+struct robust_list_head;
+struct bio;
+struct fs_struct;
+struct bts_context;
+struct perf_event_context;
+# 121 "include/linux/sched.h"
+extern unsigned long avenrun[];
+extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
+# 136 "include/linux/sched.h"
+extern unsigned long total_forks;
+extern int nr_threads;
+extern __attribute__((section(".discard"), unused)) char __pcpu_scope_process_counts; extern __attribute__((section(".data" ""))) __typeof__(unsigned long) per_cpu__process_counts;
+extern int nr_processes(void);
+extern unsigned long nr_running(void);
+extern unsigned long nr_uninterruptible(void);
+extern unsigned long nr_iowait(void);
+extern unsigned long nr_iowait_cpu(void);
+extern unsigned long this_cpu_load(void);
+
+
+extern void calc_global_load(void);
+extern u64 cpu_nr_migrations(int cpu);
+
+extern unsigned long get_parent_ip(unsigned long addr);
+
+struct seq_file;
+struct cfs_rq;
+struct task_group;
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void
+proc_sched_show_task(struct task_struct *p, struct seq_file *m)
+{
+}
+static inline __attribute__((always_inline)) void proc_sched_set_task(struct task_struct *p)
+{
+}
+static inline __attribute__((always_inline)) void
+print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
+{
+}
+
+
+extern unsigned long long time_sync_thresh;
+# 253 "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 int runqueue_is_locked(int cpu);
+extern void task_rq_unlock_wait(struct task_struct *p);
+
+extern cpumask_var_t nohz_cpu_mask;
+
+
+
+
+static inline __attribute__((always_inline)) int select_nohz_load_balancer(int cpu)
+{
+ return 0;
+}
+
+
+
+
+
+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 update_process_times(int user);
+extern void scheduler_tick(void);
+
+extern void sched_show_task(struct task_struct *p);
+# 317 "include/linux/sched.h"
+static inline __attribute__((always_inline)) void softlockup_tick(void)
+{
+}
+static inline __attribute__((always_inline)) void touch_softlockup_watchdog(void)
+{
+}
+static inline __attribute__((always_inline)) void touch_all_softlockup_watchdogs(void)
+{
+}
+
+
+
+extern unsigned int sysctl_hung_task_panic;
+extern unsigned long sysctl_hung_task_check_count;
+extern unsigned long sysctl_hung_task_timeout_secs;
+extern unsigned long sysctl_hung_task_warnings;
+extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
+      void *buffer,
+      size_t *lenp, loff_t *ppos);
+
+
+
+
+
+
+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);
+ void schedule(void);
+extern int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner);
+
+struct nsproxy;
+struct user_namespace;
+# 374 "include/linux/sched.h"
+extern int sysctl_max_map_count;
+
+# 1 "include/linux/aio.h" 1
+
+
+
+
+
+# 1 "include/linux/aio_abi.h" 1
+# 31 "include/linux/aio_abi.h"
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/byteorder.h" 1
+# 32 "include/linux/aio_abi.h" 2
+
+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,
+};
+# 58 "include/linux/aio_abi.h"
+struct io_event {
+ __u64 data;
+ __u64 obj;
+ __s64 res;
+ __s64 res2;
+};
+# 79 "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;
+};
+# 31 "include/linux/uio.h"
+struct kvec {
+ void *iov_base;
+ size_t iov_len;
+};
+# 43 "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 eventfd_ctx *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 hlist_node list;
+
+ 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;
+
+ struct rcu_head rcu_head;
+};
+
+
+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);
+# 228 "include/linux/aio.h"
+static inline __attribute__((always_inline)) struct kiocb *list_kiocb(struct list_head *h)
+{
+ return ({ const typeof( ((struct kiocb *)0)->ki_list ) *__mptr = (h); (struct kiocb *)( (char *)__mptr - __builtin_offsetof(struct kiocb,ki_list) );});
+}
+
+
+extern unsigned long aio_nr;
+extern unsigned long aio_max_nr;
+# 377 "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);
+# 424 "include/linux/sched.h"
+static inline __attribute__((always_inline)) unsigned long get_mm_hiwater_rss(struct mm_struct *mm)
+{
+ return ({ typeof(mm->hiwater_rss) _max1 = (mm->hiwater_rss); typeof((((mm)->_file_rss) + ((mm)->_anon_rss))) _max2 = ((((mm)->_file_rss) + ((mm)->_anon_rss))); (void) (&_max1 == &_max2); _max1 > _max2 ? _max1 : _max2; });
+}
+
+static inline __attribute__((always_inline)) void setmax_mm_hiwater_rss(unsigned long *maxrss,
+      struct mm_struct *mm)
+{
+ unsigned long hiwater_rss = get_mm_hiwater_rss(mm);
+
+ if (*maxrss < hiwater_rss)
+  *maxrss = hiwater_rss;
+}
+
+static inline __attribute__((always_inline)) unsigned long get_mm_hiwater_vm(struct mm_struct *mm)
+{
+ return ({ typeof(mm->hiwater_vm) _max1 = (mm->hiwater_vm); typeof(mm->total_vm) _max2 = (mm->total_vm); (void) (&_max1 == &_max2); _max1 > _max2 ? _max1 : _max2; });
+}
+
+extern void set_dumpable(struct mm_struct *mm, int value);
+extern int get_dumpable(struct mm_struct *mm);
+# 481 "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;
+};
+
+struct cpu_itimer {
+ cputime_t expires;
+ cputime_t incr;
+ u32 error;
+ u32 incr_error;
+};
+# 514 "include/linux/sched.h"
+struct task_cputime {
+ cputime_t utime;
+ cputime_t stime;
+ unsigned long long sum_exec_runtime;
+};
+# 550 "include/linux/sched.h"
+struct thread_group_cputimer {
+ struct task_cputime cputime;
+ int running;
+ spinlock_t lock;
+};
+# 563 "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;
+
+
+
+
+
+ int notify_count;
+ struct task_struct *group_exit_task;
+
+
+ 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;
+
+
+
+
+
+
+ struct cpu_itimer it[2];
+
+
+
+
+
+ struct thread_group_cputimer cputimer;
+
+
+ struct task_cputime cputime_expires;
+
+ struct list_head cpu_timers[3];
+
+ struct pid *tty_old_pgrp;
+
+
+ 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 maxrss, cmaxrss;
+ struct task_io_accounting ioac;
+
+
+
+
+
+
+
+ unsigned long long sum_sched_runtime;
+# 654 "include/linux/sched.h"
+ struct rlimit rlim[16];
+# 663 "include/linux/sched.h"
+ unsigned audit_tty;
+ struct tty_audit_buf *tty_audit_buf;
+
+
+ int oom_adj;
+};
+# 692 "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;
+
+
+ atomic_t epoll_watches;
+
+
+
+ unsigned long mq_bytes;
+
+ unsigned long locked_shm;
+
+
+ struct key *uid_keyring;
+ struct key *session_keyring;
+
+
+
+ struct hlist_node uidhash_node;
+ uid_t uid;
+ struct user_namespace *user_ns;
+
+
+ struct task_group *tg;
+
+ struct kobject kobj;
+ struct delayed_work work;
+
+
+
+
+
+
+};
+
+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;
+
+
+struct sched_info {
+
+ unsigned long pcount;
+ unsigned long long run_delay;
+
+
+ unsigned long long last_arrival,
+      last_queued;
+
+
+ unsigned int bkl_count;
+
+};
+# 803 "include/linux/sched.h"
+static inline __attribute__((always_inline)) int sched_info_on(void)
+{
+
+ return 1;
+
+
+
+
+
+
+}
+
+enum cpu_idle_type {
+ CPU_IDLE,
+ CPU_NOT_IDLE,
+ CPU_NEWLY_IDLE,
+ CPU_MAX_IDLE_TYPES
+};
+# 1033 "include/linux/sched.h"
+struct sched_domain_attr;
+
+static inline __attribute__((always_inline)) void
+partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
+   struct sched_domain_attr *dattr_new)
+{
+}
+
+
+
+struct io_context;
+
+
+
+
+
+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);
+
+ void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags);
+
+ struct task_struct * (*pick_next_task) (struct rq *rq);
+ void (*put_prev_task) (struct rq *rq, struct task_struct *p);
+# 1100 "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 (*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);
+
+ unsigned int (*get_rr_interval) (struct task_struct *task);
+
+
+ void (*moved_group) (struct task_struct *p);
+
+};
+
+struct load_weight {
+ unsigned long weight, inv_weight;
+};
+# 1132 "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;
+
+ u64 nr_migrations;
+
+ u64 start_runtime;
+ u64 avg_wakeup;
+
+ u64 avg_running;
+
+
+ u64 wait_start;
+ u64 wait_max;
+ u64 wait_count;
+ u64 wait_sum;
+ u64 iowait_count;
+ u64 iowait_sum;
+
+ u64 sleep_start;
+ u64 sleep_max;
+ s64 sum_sleep_runtime;
+
+ u64 block_start;
+ u64 block_max;
+ u64 exec_max;
+ u64 slice_max;
+
+ u64 nr_migrations_cold;
+ u64 nr_failed_migrations_affine;
+ u64 nr_failed_migrations_running;
+ u64 nr_failed_migrations_hot;
+ u64 nr_forced_migrations;
+ u64 nr_forced2_migrations;
+
+ u64 nr_wakeups;
+ u64 nr_wakeups_sync;
+ u64 nr_wakeups_migrate;
+ u64 nr_wakeups_local;
+ u64 nr_wakeups_remote;
+ u64 nr_wakeups_affine;
+ u64 nr_wakeups_affine_attempts;
+ u64 nr_wakeups_passive;
+ u64 nr_wakeups_idle;
+
+
+
+ struct sched_entity *parent;
+
+ struct cfs_rq *cfs_rq;
+
+ struct cfs_rq *my_q;
+
+};
+
+struct sched_rt_entity {
+ struct list_head run_list;
+ unsigned long timeout;
+ unsigned int time_slice;
+ int nr_cpus_allowed;
+
+ struct sched_rt_entity *back;
+
+
+
+
+
+
+
+};
+
+struct rcu_node;
+
+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;
+ unsigned int rt_priority;
+ const struct sched_class *sched_class;
+ struct sched_entity se;
+ struct sched_rt_entity rt;
+# 1249 "include/linux/sched.h"
+ unsigned char fpu_counter;
+
+
+
+
+ unsigned int policy;
+ cpumask_t cpus_allowed;
+# 1265 "include/linux/sched.h"
+ struct sched_info sched_info;
+
+
+ struct list_head tasks;
+ struct plist_node pushable_tasks;
+
+ struct mm_struct *mm, *active_mm;
+
+
+ int exit_state;
+ int exit_code, exit_signal;
+ int pdeath_signal;
+
+ unsigned int personality;
+ unsigned did_exec:1;
+ unsigned in_execve:1;
+
+ unsigned in_iowait:1;
+
+
+
+ unsigned sched_reset_on_fork:1;
+
+ pid_t pid;
+ pid_t tgid;
+# 1301 "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 list_head ptraced;
+ struct list_head ptrace_entry;
+
+
+
+
+
+ struct bts_context *bts;
+
+
+ struct pid_link pids[PIDTYPE_MAX];
+ struct list_head thread_group;
+
+ struct completion *vfork_done;
+ int *set_child_tid;
+ int *clear_child_tid;
+
+ 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;
+
+ struct task_cputime cputime_expires;
+ struct list_head cpu_timers[3];
+
+
+ const struct cred *real_cred;
+
+ const struct cred *cred;
+
+ struct mutex cred_guard_mutex;
+
+
+ struct cred *replacement_session_keyring;
+
+ char comm[16];
+
+
+
+
+ int link_count, total_link_count;
+
+
+
+
+
+
+ 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;
+
+
+
+ struct irqaction *irqaction;
+
+
+
+ spinlock_t pi_lock;
+
+
+
+ struct plist_head pi_waiters;
+
+ struct rt_mutex_waiter *pi_blocked_on;
+
+
+
+
+ struct mutex_waiter *blocked_on;
+# 1439 "include/linux/sched.h"
+ u64 curr_chain_key;
+ int lockdep_depth;
+ unsigned int lockdep_recursion;
+ struct held_lock held_locks[48UL];
+ gfp_t lockdep_reclaim_gfp;
+
+
+
+ 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;
+# 1478 "include/linux/sched.h"
+ struct robust_list_head *robust_list;
+
+
+
+ struct list_head pi_state_list;
+ struct futex_pi_state *pi_state_cache;
+# 1494 "include/linux/sched.h"
+ atomic_t fs_excl;
+ struct rcu_head rcu;
+
+
+
+
+ struct pipe_inode_info *splice_pipe;
+
+
+
+
+ int make_it_fail;
+
+ struct prop_local_single dirties;
+# 1516 "include/linux/sched.h"
+ unsigned long timer_slack_ns;
+ unsigned long default_timer_slack_ns;
+
+ struct list_head *scm_work_list;
+# 1537 "include/linux/sched.h"
+ unsigned long trace;
+
+ unsigned long trace_recursion;
+
+ unsigned long stack_start;
+};
+# 1566 "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)) 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;
+# 1618 "include/linux/sched.h"
+pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
+   struct pid_namespace *ns);
+
+static inline __attribute__((always_inline)) pid_t task_pid_nr(struct task_struct *tsk)
+{
+ return tsk->pid;
+}
+
+static inline __attribute__((always_inline)) pid_t task_pid_nr_ns(struct task_struct *tsk,
+     struct pid_namespace *ns)
+{
+ return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
+}
+
+static inline __attribute__((always_inline)) pid_t task_pid_vnr(struct task_struct *tsk)
+{
+ return __task_pid_nr_ns(tsk, PIDTYPE_PID, ((void *)0));
+}
+
+
+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_ns(struct task_struct *tsk,
+     struct pid_namespace *ns)
+{
+ return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
+}
+
+static inline __attribute__((always_inline)) pid_t task_pgrp_vnr(struct task_struct *tsk)
+{
+ return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ((void *)0));
+}
+
+
+static inline __attribute__((always_inline)) pid_t task_session_nr_ns(struct task_struct *tsk,
+     struct pid_namespace *ns)
+{
+ return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
+}
+
+static inline __attribute__((always_inline)) pid_t task_session_vnr(struct task_struct *tsk)
+{
+ return __task_pid_nr_ns(tsk, PIDTYPE_SID, ((void *)0));
+}
+
+
+static inline __attribute__((always_inline)) pid_t task_pgrp_nr(struct task_struct *tsk)
+{
+ return task_pgrp_nr_ns(tsk, &init_pid_ns);
+}
+# 1688 "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_sub_return(1, (&t->usage)) == 0))
+  __put_task_struct(t);
+}
+
+extern cputime_t task_utime(struct task_struct *p);
+extern cputime_t task_stime(struct task_struct *p);
+extern cputime_t task_gtime(struct task_struct *p);
+# 1803 "include/linux/sched.h"
+static inline __attribute__((always_inline)) void rcu_copy_process(struct task_struct *p)
+{
+}
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int set_cpus_allowed_ptr(struct task_struct *p,
+           const struct cpumask *new_mask)
+{
+ if (!test_bit(cpumask_check(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);
+}
+# 1839 "include/linux/sched.h"
+extern unsigned long long sched_clock(void);
+
+extern void sched_clock_init(void);
+extern u64 sched_clock_cpu(int cpu);
+
+
+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)
+{
+}
+# 1866 "include/linux/sched.h"
+extern unsigned long long cpu_clock(int cpu);
+
+extern unsigned long long
+task_sched_runtime(struct task_struct *task);
+extern unsigned long long thread_group_sched_runtime(struct task_struct *task);
+# 1879 "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_shares_ratelimit;
+extern unsigned int sysctl_sched_shares_thresh;
+extern unsigned int sysctl_sched_child_runs_first;
+# 1919 "include/linux/sched.h"
+static inline __attribute__((always_inline)) unsigned int get_sysctl_timer_migration(void)
+{
+ return 1;
+}
+
+extern unsigned int sysctl_sched_rt_period;
+extern int sysctl_sched_rt_runtime;
+
+int sched_rt_handler(struct ctl_table *table, int write,
+  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);
+# 1945 "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 int sched_setscheduler_nocheck(struct task_struct *, int,
+          struct sched_param *);
+extern struct task_struct *idle_task(int cpu);
+extern struct task_struct *curr_task(int cpu);
+extern void set_curr_task(int cpu, struct task_struct *p);
+
+void yield(void);
+
+
+
+
+extern struct exec_domain default_exec_domain;
+
+union thread_union {
+ struct thread_info thread_info;
+ unsigned long stack[8192/sizeof(long)];
+};
+
+
+static inline __attribute__((always_inline)) int kstack_end(void *addr)
+{
+
+
+
+ return !(((unsigned long)addr+sizeof(void*)-1) & (8192 -sizeof(void*)));
+}
+
+
+extern union thread_union init_thread_union;
+extern struct task_struct init_task;
+
+extern struct mm_struct init_mm;
+
+extern struct pid_namespace init_pid_ns;
+# 1998 "include/linux/sched.h"
+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 release_uids(struct user_namespace *ns);
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/current.h" 1
+# 2015 "include/linux/sched.h" 2
+
+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 void proc_caches_init(void);
+extern void flush_signals(struct task_struct *);
+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 { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _spin_lock_irqsave(&tsk->sighand->siglock); } while (0);
+ ret = dequeue_signal(tsk, mask, info);
+ do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _spin_unlock_irqrestore(&tsk->sighand->siglock, flags); } 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 int do_notify_parent(struct task_struct *, int);
+extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
+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 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_sub_return(1, (&mm->mm_count)) == 0)), 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(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);
+
+
+
+
+
+static inline __attribute__((always_inline)) void wait_task_context_switch(struct task_struct *p) {}
+static inline __attribute__((always_inline)) unsigned long wait_task_inactive(struct task_struct *p,
+            long match_state)
+{
+ return 1;
+}
+# 2167 "include/linux/sched.h"
+extern bool current_is_single_threaded(void);
+# 2188 "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);
+}
+
+
+
+
+static inline __attribute__((always_inline)) int task_detached(struct task_struct *p)
+{
+ return p->exit_signal == -1;
+}
+# 2228 "include/linux/sched.h"
+static inline __attribute__((always_inline)) void task_lock(struct task_struct *p)
+{
+ _spin_lock(&p->alloc_lock);
+}
+
+static inline __attribute__((always_inline)) void task_unlock(struct task_struct *p)
+{
+ _spin_unlock(&p->alloc_lock);
+}
+
+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 { ({ unsigned long __dummy; typeof(*flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _spin_unlock_irqrestore(&tsk->sighand->siglock, *flags); } 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);
+}
+
+
+
+static inline __attribute__((always_inline)) int object_is_on_stack(void *obj)
+{
+ void *stack = (((current_thread_info()->task))->stack);
+
+ return (obj >= stack) && (obj < (stack + 8192));
+}
+
+extern void thread_info_cache_init(void);
+
+
+static inline __attribute__((always_inline)) unsigned long stack_not_used(struct task_struct *p)
+{
+ unsigned long *n = end_of_stack(p);
+
+ do {
+  n++;
+ } while (!*n);
+
+ return (unsigned long)n - (unsigned long)end_of_stack(p);
+}
+
+
+
+
+
+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 restart_syscall(void)
+{
+ set_tsk_thread_flag((current_thread_info()->task), 1);
+ return -513;
+}
+
+static inline __attribute__((always_inline)) int signal_pending(struct task_struct *p)
+{
+ return __builtin_expect(!!(test_tsk_thread_flag(p,1)), 0);
+}
+
+static inline __attribute__((always_inline)) int __fatal_signal_pending(struct task_struct *p)
+{
+ return __builtin_expect(!!(sigismember(&p->pending.signal, 9)), 0);
+}
+
+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 signal_pending_state(long state, struct task_struct *p)
+{
+ if (!(state & (1 | 128)))
+  return 0;
+ if (!signal_pending(p))
+  return 0;
+
+ return (state & 1) || __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);
+}
+# 2373 "include/linux/sched.h"
+extern int _cond_resched(void);
+
+
+
+
+
+
+extern int __cond_resched_lock(spinlock_t *lock);
+# 2393 "include/linux/sched.h"
+extern int __cond_resched_softirq(void);
+# 2405 "include/linux/sched.h"
+static inline __attribute__((always_inline)) int spin_needbreak(spinlock_t *lock)
+{
+
+
+
+ return 0;
+
+}
+
+
+
+
+void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
+void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
+
+static inline __attribute__((always_inline)) void thread_group_cputime_init(struct signal_struct *sig)
+{
+ sig->cputimer.cputime = (struct task_cputime) { .utime = (0UL), .stime = (0UL), .sum_exec_runtime = 0, };
+ do { static struct lock_class_key __key; __spin_lock_init((&sig->cputimer.lock), "&sig->cputimer.lock", &__key); } while (0);
+ sig->cputimer.running = 0;
+}
+
+static inline __attribute__((always_inline)) void thread_group_cputime_free(struct signal_struct *sig)
+{
+}
+
+
+
+
+
+
+
+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);
+# 2456 "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)
+{
+}
+
+
+
+extern void arch_pick_mmap_layout(struct mm_struct *mm);
+
+
+extern void
+__trace_special(void *__tr, void *__data,
+  unsigned long arg1, unsigned long arg2, unsigned long arg3);
+# 2481 "include/linux/sched.h"
+extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
+extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
+
+extern void normalize_rt_tasks(void);
+
+
+
+extern struct task_group init_task_group;
+
+extern struct task_group root_task_group;
+extern void set_tg_uid(struct user_struct *user);
+
+
+extern struct task_group *sched_create_group(struct task_group *parent);
+extern void sched_destroy_group(struct task_group *tg);
+extern void sched_move_task(struct task_struct *tsk);
+
+extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
+extern unsigned long sched_group_shares(struct task_group *tg);
+# 2512 "include/linux/sched.h"
+extern int task_can_switch_user(struct user_struct *up,
+     struct task_struct *tsk);
+# 2536 "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)
+{
+}
+# 2560 "include/linux/sched.h"
+extern void task_oncpu_function_call(struct task_struct *p,
+         void (*func) (void *info), void *info);
+
+
+
+
+
+
+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)
+{
+}
+# 16 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h" 2
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/segment.h" 1
+# 20 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/sections.h" 1
+# 11 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/sections.h"
+extern unsigned long memory_mtd_start, memory_mtd_end, mtd_size;
+
+extern unsigned long _ramstart, _ramend, _rambase;
+extern unsigned long memory_start, memory_end, physical_mem_end;
+
+
+
+
+
+
+extern char _stext_l1[], _etext_l1[], _text_l1_lma[], __attribute__((weak)) _text_l1_len[];
+extern char _sdata_l1[], _edata_l1[], _sbss_l1[], _ebss_l1[],
+ _data_l1_lma[], __attribute__((weak)) _data_l1_len[];
+extern char _sdata_b_l1[], _edata_b_l1[], _sbss_b_l1[], _ebss_b_l1[],
+ _data_b_l1_lma[], __attribute__((weak)) _data_b_l1_len[];
+extern char _stext_l2[], _etext_l2[], _sdata_l2[], _edata_l2[],
+ _sbss_l2[], _ebss_l2[], _l2_lma[], __attribute__((weak)) _l2_len[];
+
+
+
+
+static inline __attribute__((always_inline)) int arch_is_kernel_text(unsigned long addr)
+{
+ return
+  ((0x14000 - 0x4000) &&
+   addr >= (unsigned long)_stext_l1 &&
+   addr < (unsigned long)_etext_l1)
+  ||
+  (0 &&
+   addr >= (unsigned long)_stext_l2 &&
+   addr < (unsigned long)_etext_l2);
+}
+
+
+static inline __attribute__((always_inline)) int arch_is_kernel_data(unsigned long addr)
+{
+ return
+  ((0x8000 - 0x4000) &&
+   addr >= (unsigned long)_sdata_l1 &&
+   addr < (unsigned long)_ebss_l1)
+  ||
+  (0x8000 &&
+   addr >= (unsigned long)_sdata_b_l1 &&
+   addr < (unsigned long)_ebss_b_l1)
+  ||
+  (0 &&
+   addr >= (unsigned long)_sdata_l2 &&
+   addr < (unsigned long)_ebss_l2);
+}
+
+
+# 1 "include/asm-generic/sections.h" 1
+
+
+
+
+
+extern char _text[], _stext[], _etext[];
+extern char _data[], _sdata[], _edata[];
+extern char __bss_start[], __bss_stop[];
+extern char __init_begin[], __init_end[];
+extern char _sinittext[], _einittext[];
+extern char _end[];
+extern char __per_cpu_load[], __per_cpu_start[], __per_cpu_end[];
+extern char __kprobes_text_start[], __kprobes_text_end[];
+extern char __initdata_begin[], __initdata_end[];
+extern char __start_rodata[], __end_rodata[];
+
+
+extern char __ctors_start[], __ctors_end[];
+# 63 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/sections.h" 2
+# 21 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h" 2
+
+
+
+
+static inline __attribute__((always_inline)) void set_fs(mm_segment_t fs)
+{
+ current_thread_info()->addr_limit = fs;
+}
+# 37 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+static inline __attribute__((always_inline)) int is_in_rom(unsigned long addr)
+{
+# 47 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+ if ((addr < _ramstart) || (addr >= _ramend))
+  return (1);
+
+
+ return (0);
+}
+# 63 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+extern int _access_ok(unsigned long addr, unsigned long size);
+# 79 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+struct exception_table_entry {
+ unsigned long insn, fixup;
+};
+# 123 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+static inline __attribute__((always_inline)) int bad_user_access_length(void)
+{
+ panic("bad_user_access_length");
+ return -1;
+}
+# 194 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+static inline __attribute__((always_inline)) unsigned long __attribute__((warn_unused_result))
+copy_from_user(void *to, const void *from, unsigned long n)
+{
+ if (_access_ok((unsigned long)(from), (n)))
+  memcpy(to, from, n);
+ else
+  return n;
+ return 0;
+}
+
+static inline __attribute__((always_inline)) unsigned long __attribute__((warn_unused_result))
+copy_to_user(void *to, const void *from, unsigned long n)
+{
+ if (_access_ok((unsigned long)(to), (n)))
+  memcpy(to, from, n);
+ else
+  return n;
+ return 0;
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) long __attribute__((warn_unused_result))
+strncpy_from_user(char *dst, const char *src, long count)
+{
+ char *tmp;
+ if (!_access_ok((unsigned long)(src), (1)))
+  return -14;
+ strncpy(dst, src, count);
+ for (tmp = dst; *tmp && count > 0; tmp++, count--) ;
+ return (tmp - dst);
+}
+# 240 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+static inline __attribute__((always_inline)) long __attribute__((warn_unused_result)) strnlen_user(const char *src, long n)
+{
+ if (!_access_ok((unsigned long)(src), (1)))
+  return 0;
+ return strnlen(src, n) + 1;
+}
+
+static inline __attribute__((always_inline)) long __attribute__((warn_unused_result)) strlen_user(const char *src)
+{
+ if (!_access_ok((unsigned long)(src), (1)))
+  return 0;
+ return strlen(src) + 1;
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) unsigned long __attribute__((warn_unused_result))
+__clear_user(void *to, unsigned long n)
+{
+ if (!_access_ok((unsigned long)(to), (n)))
+  return n;
+ memset(to, 0, n);
+ return 0;
+}
+# 276 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/uaccess.h"
+enum {
+ BFIN_MEM_ACCESS_CORE = 0,
+ BFIN_MEM_ACCESS_CORE_ONLY,
+ BFIN_MEM_ACCESS_DMA,
+ BFIN_MEM_ACCESS_IDMA,
+ BFIN_MEM_ACCESS_ITEST,
+};
+
+
+
+
+
+
+int bfin_mem_access_type(unsigned long addr, unsigned long size);
+# 6 "include/linux/uaccess.h" 2
+# 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);
+# 7 "include/linux/highmem.h" 2
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cacheflush.h" 1
+# 15 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cacheflush.h"
+extern void blackfin_icache_flush_range(unsigned long start_address, unsigned long end_address);
+extern void blackfin_dcache_flush_range(unsigned long start_address, unsigned long end_address);
+extern void blackfin_dcache_invalidate_range(unsigned long start_address, unsigned long end_address);
+extern void blackfin_dflush_page(void *page);
+extern void blackfin_invalidate_entire_dcache(void);
+extern void blackfin_invalidate_entire_icache(void);
+# 37 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cacheflush.h"
+static inline __attribute__((always_inline)) void flush_icache_range(unsigned start, unsigned end)
+{
+# 56 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cacheflush.h"
+ SSYNC();
+
+ if (end <= physical_mem_end) {
+  blackfin_icache_flush_range(start, end);
+  do { } while (0);
+ }
+
+
+
+
+
+
+
+}
+# 91 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/cacheflush.h"
+extern unsigned long reserved_mem_dcache_on;
+extern unsigned long reserved_mem_icache_on;
+
+static inline __attribute__((always_inline)) int bfin_addr_dcacheable(unsigned long addr)
+{
+
+ if (addr < (_ramend - (1024 * 1024)))
+  return 1;
+
+
+ if (reserved_mem_dcache_on &&
+  addr >= _ramend && addr < physical_mem_end)
+  return 1;
+
+
+
+
+
+
+ return 0;
+}
+# 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)
+{
+}
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/kmap_types.h" 1
+# 1 "include/asm-generic/kmap_types.h" 1
+# 10 "include/asm-generic/kmap_types.h"
+enum km_type {
+ KM_BOUNCE_READ,
+ KM_SKB_SUNRPC_DATA,
+ KM_SKB_DATA_SOFTIRQ,
+ KM_USER0,
+ KM_USER1,
+ KM_BIO_SRC_IRQ,
+ KM_BIO_DST_IRQ,
+ KM_PTE0,
+ KM_PTE1,
+ KM_IRQ0,
+ KM_IRQ1,
+ KM_SOFTIRQ0,
+ KM_SOFTIRQ1,
+ KM_SYNC_ICACHE,
+ KM_SYNC_DCACHE,
+
+ KM_UML_USERCOPY,
+ KM_IRQ_PTE,
+ KM_NMI,
+ KM_NMI_PTE,
+ KM_TYPE_NR
+};
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/kmap_types.h" 2
+# 23 "include/linux/highmem.h" 2
+
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void debug_kmap_atomic(enum km_type type)
+{
+}
+# 47 "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 { __might_sleep("include/linux/highmem.h", 54, 0); _cond_resched(); } while (0);
+ return lowmem_page_address(page);
+}
+
+static inline __attribute__((always_inline)) void kunmap(struct page *page)
+{
+}
+
+static inline __attribute__((always_inline)) void *kmap_atomic(struct page *page, enum km_type idx)
+{
+ pagefault_disable();
+ return lowmem_page_address(page);
+}
+# 80 "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((addr), 0, (1UL << 12));
+ do { pagefault_enable(); } while (0);
+}
+# 103 "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;
+}
+# 126 "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)0x08u), vma, vaddr);
+}
+
+static inline __attribute__((always_inline)) void clear_highpage(struct page *page)
+{
+ void *kaddr = kmap_atomic(page, KM_USER0);
+ memset((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 { asm volatile( "1:    .hword  %0\n" " .section __bug_table,\"a\",@progbits\n" "2:     .long   1b\n" " .long   %1\n" " .short  %2\n" " .short  %3\n" " .org    2b + %4\n" "    .previous" : : "i"(0xefcd), "i"("include/linux/highmem.h"), "i"(146), "i"(0), "i"(sizeof(struct bug_entry))); for (;;); } 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 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((vto), (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((vto), (vfrom), (1UL << 12));
+ do { pagefault_enable(); } while (0);
+ do { pagefault_enable(); } while (0);
+}
+# 11 "include/linux/pagemap.h" 2
+
+
+
+
+# 1 "include/linux/hardirq.h" 1
+# 9 "include/linux/hardirq.h"
+# 1 "include/linux/ftrace_irq.h" 1
+# 9 "include/linux/ftrace_irq.h"
+static inline __attribute__((always_inline)) void ftrace_nmi_enter(void) { }
+static inline __attribute__((always_inline)) void ftrace_nmi_exit(void) { }
+# 10 "include/linux/hardirq.h" 2
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/hardirq.h" 1
+# 12 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/hardirq.h"
+extern void ack_bad_irq(unsigned int irq);
+
+
+
+
+
+# 1 "include/asm-generic/hardirq.h" 1
+
+
+
+
+
+# 1 "include/linux/irq.h" 1
+# 21 "include/linux/irq.h"
+# 1 "include/linux/irqreturn.h" 1
+# 10 "include/linux/irqreturn.h"
+enum irqreturn {
+ IRQ_NONE,
+ IRQ_HANDLED,
+ IRQ_WAKE_THREAD,
+};
+
+typedef enum irqreturn irqreturn_t;
+# 22 "include/linux/irq.h" 2
+# 1 "include/linux/irqnr.h" 1
+# 26 "include/linux/irqnr.h"
+extern int nr_irqs;
+extern struct irq_desc *irq_to_desc(unsigned int irq);
+# 23 "include/linux/irq.h" 2
+
+
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq_regs.h" 1
+# 1 "include/asm-generic/irq_regs.h" 1
+# 21 "include/asm-generic/irq_regs.h"
+extern __attribute__((section(".discard"), unused)) char __pcpu_scope___irq_regs; extern __attribute__((section(".data" ""))) __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 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/irq_regs.h" 2
+# 30 "include/linux/irq.h" 2
+
+struct irq_desc;
+typedef void (*irq_flow_handler_t)(unsigned int irq,
+         struct irq_desc *desc);
+# 83 "include/linux/irq.h"
+struct proc_dir_entry;
+struct msi_desc;
+# 111 "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);
+ int (*set_affinity)(unsigned int irq,
+     const struct cpumask *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 (*bus_lock)(unsigned int irq);
+ void (*bus_sync_unlock)(unsigned int irq);
+# 142 "include/linux/irq.h"
+ const char *typename;
+};
+
+struct timer_rand_state;
+struct irq_2_iommu;
+# 175 "include/linux/irq.h"
+struct irq_desc {
+ unsigned int irq;
+ struct timer_rand_state *timer_rand_state;
+ unsigned int *kstat_irqs;
+
+
+
+ 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 long last_unhandled;
+ unsigned int irqs_unhandled;
+ spinlock_t lock;
+
+
+
+
+
+
+
+ atomic_t threads_active;
+ wait_queue_head_t wait_for_threads;
+
+ struct proc_dir_entry *dir;
+
+ const char *name;
+} ;
+
+extern void arch_init_copy_chip_data(struct irq_desc *old_desc,
+     struct irq_desc *desc, int node);
+extern void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc);
+
+
+extern struct irq_desc irq_desc[(48 +1)];
+
+
+
+
+
+static inline __attribute__((always_inline)) struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
+{
+ return desc;
+}
+
+
+extern struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node);
+
+
+
+
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/hw_irq.h" 1
+# 1 "include/asm-generic/hw_irq.h" 1
+# 1 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/hw_irq.h" 2
+# 234 "include/linux/irq.h" 2
+
+extern int setup_irq(unsigned int irq, struct irqaction *new);
+extern void remove_irq(unsigned int irq, struct irqaction *act);
+# 270 "include/linux/irq.h"
+extern int no_irq_affinity;
+
+static inline __attribute__((always_inline)) int irq_balancing_disabled(unsigned int irq)
+{
+ struct irq_desc *desc;
+
+ desc = irq_to_desc(irq);
+ return desc->status & 0x00400000;
+}
+
+
+extern irqreturn_t 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 void handle_nested_irq(unsigned int irq);
+# 308 "include/linux/irq.h"
+static inline __attribute__((always_inline)) void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)
+{
+
+ desc->handle_irq(irq, desc);
+
+
+
+
+
+
+}
+
+static inline __attribute__((always_inline)) void generic_handle_irq(unsigned int irq)
+{
+ generic_handle_irq_desc(irq, irq_to_desc(irq));
+}
+
+
+extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
+      irqreturn_t 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)
+{
+ struct irq_desc *desc;
+
+ desc = irq_to_desc(irq);
+ desc->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_nested_thread(unsigned int irq, int nest);
+
+extern void set_irq_noprobe(unsigned int irq);
+extern void set_irq_probe(unsigned int irq);
+
+
+extern unsigned int create_irq_nr(unsigned int irq_want, int node);
+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_to_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);
+# 500 "include/linux/irq.h"
+static inline __attribute__((always_inline)) bool alloc_desc_masks(struct irq_desc *desc, int node,
+        bool boot)
+{
+ return true;
+}
+
+static inline __attribute__((always_inline)) void init_desc_masks(struct irq_desc *desc)
+{
+}
+
+static inline __attribute__((always_inline)) void init_copy_desc_masks(struct irq_desc *old_desc,
+     struct irq_desc *new_desc)
+{
+}
+
+static inline __attribute__((always_inline)) void free_desc_masks(struct irq_desc *old_desc,
+       struct irq_desc *new_desc)
+{
+}
+# 7 "include/asm-generic/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[];
+# 13 "include/asm-generic/hardirq.h" 2
+# 19 "/usr/local/src/blackfin/git/linux-kernel/arch/blackfin/include/asm/hardirq.h" 2
+# 11 "include/linux/hardirq.h" 2
+# 128 "include/linux/hardirq.h"
+extern void synchronize_irq(unsigned int irq);
+
+
+
+
+struct task_struct;
+
+
+static inline __attribute__((always_inline)) void account_system_vtime(struct task_struct *tsk)
+{
+}
+
+
+
+extern void rcu_irq_enter(void);
+extern void rcu_irq_exit(void);
+extern void rcu_nmi_enter(void);
+extern void rcu_nmi_exit(void);
+# 169 "include/linux/hardirq.h"
+extern void irq_enter(void);
+# 184 "include/linux/hardirq.h"
+extern void irq_exit(void);
+# 16 "include/linux/pagemap.h" 2
+
+
+
+
+
+enum mapping_flags {
+ AS_EIO = 22 + 0,
+ AS_ENOSPC = 22 + 1,
+ AS_MM_ALL_LOCKS = 22 + 2,
+ AS_UNEVICTABLE = 22 + 3,
+};
+
+static inline __attribute__((always_inline)) void mapping_set_error(struct address_space *mapping, int error)
+{
+ if (__builtin_expect(!!(error), 0)) {
+  if (error == -28)
+   set_bit(AS_ENOSPC, &mapping->flags);
+  else
+   set_bit(AS_EIO, &mapping->flags);
+ }
+}
+
+static inline __attribute__((always_inline)) void mapping_set_unevictable(struct address_space *mapping)
+{
+ set_bit(AS_UNEVICTABLE, &mapping->flags);
+}
+
+static inline __attribute__((always_inline)) void mapping_clear_unevictable(struct address_space *mapping)
+{
+ clear_bit(AS_UNEVICTABLE, &mapping->flags);
+}
+
+static inline __attribute__((always_inline)) int mapping_unevictable(struct address_space *mapping)
+{
+ if (__builtin_expect(!!(mapping), 1))
+  return test_bit(AS_UNEVICTABLE, &mapping->flags);
+ return !!mapping;
+}
+
+static inline __attribute__((always_inline)) gfp_t mapping_gfp_mask(struct address_space * mapping)
+{
+ return ( gfp_t)mapping->flags & (( gfp_t)((1 << 22) - 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 << 22) - 1))) |
+    ( unsigned long)mask;
+}
+# 85 "include/linux/pagemap.h"
+void release_pages(struct page **pages, int nr, int cold);
+# 131 "include/linux/pagemap.h"
+static inline __attribute__((always_inline)) int page_cache_get_speculative(struct page *page)
+{
+ do { } while (0);
+# 148 "include/linux/pagemap.h"
+ do { } while (0);
+ atomic_inc(&page->_count);
+# 161 "include/linux/pagemap.h"
+ do { } while (0);
+
+ return 1;
+}
+
+
+
+
+static inline __attribute__((always_inline)) int page_cache_add_speculative(struct page *page, int count)
+{
+ do { } while (0);
+
+
+
+
+
+ do { } while (0);
+ atomic_add(count, &page->_count);
+
+
+
+
+
+ do { } while (0);
+
+ return 1;
+}
+
+static inline __attribute__((always_inline)) int page_freeze_refs(struct page *page, int count)
+{
+ return __builtin_expect(!!((((__typeof__(*((&((&page->_count)->counter)))))__cmpxchg_local_generic(((&((&page->_count)->counter))), (unsigned long)(((count))), (unsigned long)(((0))), sizeof(*((&((&page->_count)->counter))))))) == count), 1);
+}
+
+static inline __attribute__((always_inline)) void page_unfreeze_refs(struct page *page, int count)
+{
+ do { } while (0);
+ do { } while (0);
+
+ (((&page->_count)->counter) = (count));
+}
+
+
+
+
+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_write_begin(struct address_space *mapping,
+   unsigned long index, unsigned flags);
+
+
+
+
+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);
+}
+
+
+
+
+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 __set_page_locked(struct page *page)
+{
+ __set_bit(PG_locked, &page->flags);
+}
+
+static inline __attribute__((always_inline)) void __clear_page_locked(struct page *page)
+{
+ __clear_bit(PG_locked, &page->flags);
+}
+
+static inline __attribute__((always_inline)) int trylock_page(struct page *page)
+{
+ return (__builtin_expect(!!(!test_and_set_bit(PG_locked, &page->flags)), 1));
+}
+
+
+
+
+static inline __attribute__((always_inline)) void lock_page(struct page *page)
+{
+ do { __might_sleep("include/linux/pagemap.h", 315, 0); _cond_resched(); } while (0);
+ if (!trylock_page(page))
+  __lock_page(page);
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) int lock_page_killable(struct page *page)
+{
+ do { __might_sleep("include/linux/pagemap.h", 327, 0); _cond_resched(); } while (0);
+ if (!trylock_page(page))
+  return __lock_page_killable(page);
+ return 0;
+}
+
+
+
+
+
+static inline __attribute__((always_inline)) void lock_page_nosync(struct page *page)
+{
+ do { __might_sleep("include/linux/pagemap.h", 339, 0); _cond_resched(); } while (0);
+ if (!trylock_page(page))
+  __lock_page_nosync(page);
+}
+
+
+
+
+
+extern void wait_on_page_bit(struct page *page, int bit_nr);
+# 357 "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);
+
+
+
+
+extern void add_page_wait_queue(struct page *page, wait_queue_t *waiter);
+
+
+
+
+
+
+
+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 = ({ int _err = 0; typeof(*(uaddr)) _x = (0); typeof(*(uaddr)) *_p = (uaddr); if (!_access_ok((unsigned long)(_p), (sizeof(*(_p))))) { _err = -14; } else { switch (sizeof (*(_p))) { case 1: __asm__ ("B""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 2: __asm__ ("W""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 4: __asm__ ("""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 8: { long _xl, _xh; _xl = ((long *)&_x)[0]; _xh = ((long *)&_x)[1]; __asm__ ("""[%1] = %0;\n\t" : :"d" (_xl),"a" (((unsigned long *)(((long *)_p)+0))) : "memory"); __asm__ ("""[%1] = %0;\n\t" : :"d" (_xh),"a" (((unsigned long *)(((long *)_p)+1))) : "memory"); } break; default: _err = (printk("<6>" "put_user_bad %s:%d %s\n", "include/linux/pagemap.h", 396, __func__), bad_user_access_length(), (-14)); break; } } _err; });
+ if (ret == 0) {
+  char *end = uaddr + size - 1;
+
+
+
+
+
+  if (((unsigned long)uaddr & (~((1UL << 12)-1))) !=
+    ((unsigned long)end & (~((1UL << 12)-1))))
+    ret = ({ int _err = 0; typeof(*(end)) _x = (0); typeof(*(end)) *_p = (end); if (!_access_ok((unsigned long)(_p), (sizeof(*(_p))))) { _err = -14; } else { switch (sizeof (*(_p))) { case 1: __asm__ ("B""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 2: __asm__ ("W""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 4: __asm__ ("""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 8: { long _xl, _xh; _xl = ((long *)&_x)[0]; _xh = ((long *)&_x)[1]; __asm__ ("""[%1] = %0;\n\t" : :"d" (_xl),"a" (((unsigned long *)(((long *)_p)+0))) : "memory"); __asm__ ("""[%1] = %0;\n\t" : :"d" (_xh),"a" (((unsigned long *)(((long *)_p)+1))) : "memory"); } break; default: _err = (printk("<6>" "put_user_bad %s:%d %s\n", "include/linux/pagemap.h", 406, __func__), bad_user_access_length(), (-14)); break; } } _err; });
+ }
+ 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 = ({ int _err = 0; unsigned long _val = 0; const typeof(*(uaddr)) *_p = (uaddr); const size_t ptr_size = sizeof(*(_p)); if (__builtin_expect(!!(_access_ok((unsigned long)(_p), (ptr_size))), 1)) { ((void)(sizeof(struct { int:-!!(ptr_size >= 8); }))); switch (ptr_size) { case 1: ({ __asm__ __volatile__ ( "%0 =" "B" "[%1]" "(Z)" ";" : "=d" (_val) : "a" (((unsigned long *)(_p)))); }); break; case 2: ({ __asm__ __volatile__ ( "%0 =" "W" "[%1]" "(Z)" ";" : "=d" (_val) : "a" (((unsigned long *)(_p)))); }); break; case 4: ({ __asm__ __volatile__ ( "%0 =" "" "[%1]" "" ";" : "=d" (_val) : "a" (((unsigned long *)(_p)))); }); break; } } else _err = -14; c = (typeof(*(uaddr)))_val; _err; });
+ if (ret == 0) {
+  const char *end = uaddr + size - 1;
+
+  if (((unsigned long)uaddr & (~((1UL << 12)-1))) !=
+    ((unsigned long)end & (~((1UL << 12)-1))))
+    ret = ({ int _err = 0; unsigned long _val = 0; const typeof(*(end)) *_p = (end); const size_t ptr_size = sizeof(*(_p)); if (__builtin_expect(!!(_access_ok((unsigned long)(_p), (ptr_size))), 1)) { ((void)(sizeof(struct { int:-!!(ptr_size >= 8); }))); switch (ptr_size) { case 1: ({ __asm__ __volatile__ ( "%0 =" "B" "[%1]" "(Z)" ";" : "=d" (_val) : "a" (((unsigned long *)(_p)))); }); break; case 2: ({ __asm__ __volatile__ ( "%0 =" "W" "[%1]" "(Z)" ";" : "=d" (_val) : "a" (((unsigned long *)(_p)))); }); break; case 4: ({ __asm__ __volatile__ ( "%0 =" "" "[%1]" "" ";" : "=d" (_val) : "a" (((unsigned long *)(_p)))); }); break; } } else _err = -14; c = (typeof(*(end)))_val; _err; });
+ }
+ return ret;
+}
+
+int add_to_page_cache_locked(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)) int add_to_page_cache(struct page *page,
+  struct address_space *mapping, unsigned long offset, gfp_t gfp_mask)
+{
+ int error;
+
+ __set_page_locked(page);
+ error = add_to_page_cache_locked(page, mapping, offset, gfp_mask);
+ if (__builtin_expect(!!(error), 0))
+  __clear_page_locked(page);
+ return error;
+}
+# 14 "include/linux/buffer_head.h" 2
+
+
+
+
+
+enum bh_state_bits {
+ BH_Uptodate,
+ BH_Dirty,
+ BH_Lock,
+ BH_Req,
+ BH_Uptodate_Lock,
+
+
+
+ BH_Mapped,
+ BH_New,
+ BH_Async_Read,
+ BH_Async_Write,
+ BH_Delay,
+ BH_Boundary,
+ BH_Write_EIO,
+ BH_Ordered,
+ BH_Eopnotsupp,
+ BH_Unwritten,
+ BH_Quiet,
+
+ BH_PrivateStart,
+
+
+};
+
+
+
+struct page;
+struct buffer_head;
+struct address_space;
+typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
+# 61 "include/linux/buffer_head.h"
+struct buffer_head {
+ unsigned long b_state;
+ struct buffer_head *b_this_page;
+ struct page *b_page;
+
+ sector_t b_blocknr;
+ size_t b_size;
+ char *b_data;
+
+ struct block_device *b_bdev;
+ bh_end_io_t *b_end_io;
+  void *b_private;
+ struct list_head b_assoc_buffers;
+ struct address_space *b_assoc_map;
+
+ atomic_t b_count;
+};
+# 115 "include/linux/buffer_head.h"
+static inline __attribute__((always_inline)) void set_buffer_uptodate(struct buffer_head *bh) { set_bit(BH_Uptodate, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_uptodate(struct buffer_head *bh) { clear_bit(BH_Uptodate, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_uptodate(const struct buffer_head *bh) { return test_bit(BH_Uptodate, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_dirty(struct buffer_head *bh) { set_bit(BH_Dirty, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_dirty(struct buffer_head *bh) { clear_bit(BH_Dirty, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_dirty(const struct buffer_head *bh) { return test_bit(BH_Dirty, &(bh)->b_state); }
+static inline __attribute__((always_inline)) int test_set_buffer_dirty(struct buffer_head *bh) { return test_and_set_bit(BH_Dirty, &(bh)->b_state); } static inline __attribute__((always_inline)) int test_clear_buffer_dirty(struct buffer_head *bh) { return test_and_clear_bit(BH_Dirty, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_locked(struct buffer_head *bh) { set_bit(BH_Lock, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_locked(struct buffer_head *bh) { clear_bit(BH_Lock, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_locked(const struct buffer_head *bh) { return test_bit(BH_Lock, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_req(struct buffer_head *bh) { set_bit(BH_Req, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_req(struct buffer_head *bh) { clear_bit(BH_Req, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_req(const struct buffer_head *bh) { return test_bit(BH_Req, &(bh)->b_state); }
+static inline __attribute__((always_inline)) int test_set_buffer_req(struct buffer_head *bh) { return test_and_set_bit(BH_Req, &(bh)->b_state); } static inline __attribute__((always_inline)) int test_clear_buffer_req(struct buffer_head *bh) { return test_and_clear_bit(BH_Req, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_mapped(struct buffer_head *bh) { set_bit(BH_Mapped, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_mapped(struct buffer_head *bh) { clear_bit(BH_Mapped, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_mapped(const struct buffer_head *bh) { return test_bit(BH_Mapped, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_new(struct buffer_head *bh) { set_bit(BH_New, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_new(struct buffer_head *bh) { clear_bit(BH_New, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_new(const struct buffer_head *bh) { return test_bit(BH_New, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_async_read(struct buffer_head *bh) { set_bit(BH_Async_Read, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_async_read(struct buffer_head *bh) { clear_bit(BH_Async_Read, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_async_read(const struct buffer_head *bh) { return test_bit(BH_Async_Read, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_async_write(struct buffer_head *bh) { set_bit(BH_Async_Write, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_async_write(struct buffer_head *bh) { clear_bit(BH_Async_Write, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_async_write(const struct buffer_head *bh) { return test_bit(BH_Async_Write, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_delay(struct buffer_head *bh) { set_bit(BH_Delay, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_delay(struct buffer_head *bh) { clear_bit(BH_Delay, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_delay(const struct buffer_head *bh) { return test_bit(BH_Delay, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_boundary(struct buffer_head *bh) { set_bit(BH_Boundary, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_boundary(struct buffer_head *bh) { clear_bit(BH_Boundary, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_boundary(const struct buffer_head *bh) { return test_bit(BH_Boundary, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_write_io_error(struct buffer_head *bh) { set_bit(BH_Write_EIO, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_write_io_error(struct buffer_head *bh) { clear_bit(BH_Write_EIO, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_write_io_error(const struct buffer_head *bh) { return test_bit(BH_Write_EIO, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_ordered(struct buffer_head *bh) { set_bit(BH_Ordered, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_ordered(struct buffer_head *bh) { clear_bit(BH_Ordered, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_ordered(const struct buffer_head *bh) { return test_bit(BH_Ordered, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_eopnotsupp(struct buffer_head *bh) { set_bit(BH_Eopnotsupp, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_eopnotsupp(struct buffer_head *bh) { clear_bit(BH_Eopnotsupp, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_eopnotsupp(const struct buffer_head *bh) { return test_bit(BH_Eopnotsupp, &(bh)->b_state); }
+static inline __attribute__((always_inline)) void set_buffer_unwritten(struct buffer_head *bh) { set_bit(BH_Unwritten, &(bh)->b_state); } static inline __attribute__((always_inline)) void clear_buffer_unwritten(struct buffer_head *bh) { clear_bit(BH_Unwritten, &(bh)->b_state); } static inline __attribute__((always_inline)) int buffer_unwritten(const struct buffer_head *bh) { return test_bit(BH_Unwritten, &(bh)->b_state); }
+# 147 "include/linux/buffer_head.h"
+void mark_buffer_dirty(struct buffer_head *bh);
+void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
+void set_bh_page(struct buffer_head *bh,
+  struct page *page, unsigned long offset);
+int try_to_free_buffers(struct page *);
+struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
+  int retry);
+void create_empty_buffers(struct page *, unsigned long,
+   unsigned long b_state);
+void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
+void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
+void end_buffer_async_write(struct buffer_head *bh, int uptodate);
+
+
+void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
+int inode_has_buffers(struct inode *);
+void invalidate_inode_buffers(struct inode *);
+int remove_inode_buffers(struct inode *inode);
+int sync_mapping_buffers(struct address_space *mapping);
+void unmap_underlying_metadata(struct block_device *bdev, sector_t block);
+
+void mark_buffer_async_write(struct buffer_head *bh);
+void __wait_on_buffer(struct buffer_head *);
+wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
+struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
+   unsigned size);
+struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
+   unsigned size);
+void __brelse(struct buffer_head *);
+void __bforget(struct buffer_head *);
+void __breadahead(struct block_device *, sector_t block, unsigned int size);
+struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
+void invalidate_bh_lrus(void);
+struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
+void free_buffer_head(struct buffer_head * bh);
+void unlock_buffer(struct buffer_head *bh);
+void __lock_buffer(struct buffer_head *bh);
+void ll_rw_block(int, int, struct buffer_head * bh[]);
+int sync_dirty_buffer(struct buffer_head *bh);
+int submit_bh(int, struct buffer_head *);
+void write_boundary_block(struct block_device *bdev,
+   sector_t bblock, unsigned blocksize);
+int bh_uptodate_or_lock(struct buffer_head *bh);
+int bh_submit_read(struct buffer_head *bh);
+
+extern int buffer_heads_over_limit;
+
+
+
+
+
+void block_invalidatepage(struct page *page, unsigned long offset);
+int block_write_full_page(struct page *page, get_block_t *get_block,
+    struct writeback_control *wbc);
+int block_write_full_page_endio(struct page *page, get_block_t *get_block,
+   struct writeback_control *wbc, bh_end_io_t *handler);
+int block_read_full_page(struct page*, get_block_t*);
+int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
+    unsigned long from);
+int block_write_begin(struct file *, struct address_space *,
+    loff_t, unsigned, unsigned,
+    struct page **, void **, get_block_t*);
+int block_write_end(struct file *, struct address_space *,
+    loff_t, unsigned, unsigned,
+    struct page *, void *);
+int generic_write_end(struct file *, struct address_space *,
+    loff_t, unsigned, unsigned,
+    struct page *, void *);
+void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
+int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
+int cont_write_begin(struct file *, struct address_space *, loff_t,
+   unsigned, unsigned, struct page **, void **,
+   get_block_t *, loff_t *);
+int generic_cont_expand_simple(struct inode *inode, loff_t size);
+int block_commit_write(struct page *page, unsigned from, unsigned to);
+int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
+    get_block_t get_block);
+void block_sync_page(struct page *);
+sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
+int block_truncate_page(struct address_space *, loff_t, get_block_t *);
+int file_fsync(struct file *, struct dentry *, int);
+int nobh_write_begin(struct file *, struct address_space *,
+    loff_t, unsigned, unsigned,
+    struct page **, void **, get_block_t*);
+int nobh_write_end(struct file *, struct address_space *,
+    loff_t, unsigned, unsigned,
+    struct page *, void *);
+int nobh_truncate_page(struct address_space *, loff_t, get_block_t *);
+int nobh_writepage(struct page *page, get_block_t *get_block,
+                        struct writeback_control *wbc);
+
+void buffer_init(void);
+
+
+
+
+
+static inline __attribute__((always_inline)) void attach_page_buffers(struct page *page,
+  struct buffer_head *head)
+{
+ get_page(page);
+ SetPagePrivate(page);
+ ((page)->private = ((unsigned long)head));
+}
+
+static inline __attribute__((always_inline)) void get_bh(struct buffer_head *bh)
+{
+        atomic_inc(&bh->b_count);
+}
+
+static inline __attribute__((always_inline)) void put_bh(struct buffer_head *bh)
+{
+        __asm__ __volatile__("": : :"memory");
+        atomic_dec(&bh->b_count);
+}
+
+static inline __attribute__((always_inline)) void brelse(struct buffer_head *bh)
+{
+ if (bh)
+  __brelse(bh);
+}
+
+static inline __attribute__((always_inline)) void bforget(struct buffer_head *bh)
+{
+ if (bh)
+  __bforget(bh);
+}
+
+static inline __attribute__((always_inline)) struct buffer_head *
+sb_bread(struct super_block *sb, sector_t block)
+{
+ return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline __attribute__((always_inline)) void
+sb_breadahead(struct super_block *sb, sector_t block)
+{
+ __breadahead(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline __attribute__((always_inline)) struct buffer_head *
+sb_getblk(struct super_block *sb, sector_t block)
+{
+ return __getblk(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline __attribute__((always_inline)) struct buffer_head *
+sb_find_get_block(struct super_block *sb, sector_t block)
+{
+ return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline __attribute__((always_inline)) void
+map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
+{
+ set_buffer_mapped(bh);
+ bh->b_bdev = sb->s_bdev;
+ bh->b_blocknr = block;
+ bh->b_size = sb->s_blocksize;
+}
+
+
+
+
+
+
+static inline __attribute__((always_inline)) void wait_on_buffer(struct buffer_head *bh)
+{
+ do { __might_sleep("include/linux/buffer_head.h", 315, 0); _cond_resched(); } while (0);
+ if (buffer_locked(bh) || ((&bh->b_count)->counter) == 0)
+  __wait_on_buffer(bh);
+}
+
+static inline __attribute__((always_inline)) int trylock_buffer(struct buffer_head *bh)
+{
+ return __builtin_expect(!!(!test_and_set_bit(BH_Lock, &bh->b_state)), 1);
+}
+
+static inline __attribute__((always_inline)) void lock_buffer(struct buffer_head *bh)
+{
+ do { __might_sleep("include/linux/buffer_head.h", 327, 0); _cond_resched(); } while (0);
+ if (!trylock_buffer(bh))
+  __lock_buffer(bh);
+}
+
+extern int __set_page_dirty_buffers(struct page *page);
+# 27 "fs/sysv/super.c" 2
+# 1 "fs/sysv/sysv.h" 1
+
+
+
+
+
+typedef __u16 __fs16;
+typedef __u32 __fs32;
+
+# 1 "include/linux/sysv_fs.h" 1
+# 13 "include/linux/sysv_fs.h"
+typedef __fs16 sysv_ino_t;
+
+
+
+
+typedef __fs32 sysv_zone_t;
+# 28 "include/linux/sysv_fs.h"
+struct xenix_super_block {
+ __fs16 s_isize;
+ __fs32 s_fsize __attribute__((packed, aligned(2)));
+
+ __fs16 s_nfree;
+ sysv_zone_t s_free[100];
+
+ __fs16 s_ninode;
+ sysv_ino_t s_inode[100];
+
+ char s_flock;
+ char s_ilock;
+ char s_fmod;
+ char s_ronly;
+ __fs32 s_time __attribute__((packed, aligned(2)));
+ __fs32 s_tfree __attribute__((packed, aligned(2)));
+ __fs16 s_tinode;
+ __fs16 s_dinfo[4];
+ char s_fname[6];
+ char s_fpack[6];
+ char s_clean;
+ char s_fill[371];
+ s32 s_magic;
+ __fs32 s_type;
+
+
+
+};
+# 66 "include/linux/sysv_fs.h"
+struct sysv4_super_block {
+ __fs16 s_isize;
+ u16 s_pad0;
+ __fs32 s_fsize;
+
+ __fs16 s_nfree;
+ u16 s_pad1;
+ sysv_zone_t s_free[50];
+
+ __fs16 s_ninode;
+ u16 s_pad2;
+ sysv_ino_t s_inode[100];
+
+ char s_flock;
+ char s_ilock;
+ char s_fmod;
+ char s_ronly;
+ __fs32 s_time;
+ __fs16 s_dinfo[4];
+ __fs32 s_tfree;
+ __fs16 s_tinode;
+ u16 s_pad3;
+ char s_fname[6];
+ char s_fpack[6];
+ s32 s_fill[12];
+ __fs32 s_state;
+ s32 s_magic;
+ __fs32 s_type;
+
+};
+
+
+struct sysv2_super_block {
+ __fs16 s_isize;
+ __fs32 s_fsize __attribute__((packed, aligned(2)));
+
+ __fs16 s_nfree;
+ sysv_zone_t s_free[50];
+
+ __fs16 s_ninode;
+ sysv_ino_t s_inode[100];
+
+ char s_flock;
+ char s_ilock;
+ char s_fmod;
+ char s_ronly;
+ __fs32 s_time __attribute__((packed, aligned(2)));
+ __fs16 s_dinfo[4];
+ __fs32 s_tfree __attribute__((packed, aligned(2)));
+ __fs16 s_tinode;
+ char s_fname[6];
+ char s_fpack[6];
+ s32 s_fill[14];
+ __fs32 s_state;
+ s32 s_magic;
+ __fs32 s_type;
+
+};
+
+
+
+
+struct v7_super_block {
+ __fs16 s_isize;
+ __fs32 s_fsize __attribute__((packed, aligned(2)));
+
+ __fs16 s_nfree;
+ sysv_zone_t s_free[50];
+
+ __fs16 s_ninode;
+ sysv_ino_t s_inode[100];
+
+ char s_flock;
+ char s_ilock;
+ char s_fmod;
+ char s_ronly;
+ __fs32 s_time __attribute__((packed, aligned(2)));
+
+ __fs32 s_tfree __attribute__((packed, aligned(2)));
+ __fs16 s_tinode;
+ __fs16 s_m;
+ __fs16 s_n;
+ char s_fname[6];
+ char s_fpack[6];
+};
+
+
+
+
+struct coh_super_block {
+ __fs16 s_isize;
+ __fs32 s_fsize __attribute__((packed, aligned(2)));
+
+ __fs16 s_nfree;
+ sysv_zone_t s_free[64] __attribute__((packed, aligned(2)));
+
+ __fs16 s_ninode;
+ sysv_ino_t s_inode[100];
+
+ char s_flock;
+ char s_ilock;
+ char s_fmod;
+ char s_ronly;
+ __fs32 s_time __attribute__((packed, aligned(2)));
+ __fs32 s_tfree __attribute__((packed, aligned(2)));
+ __fs16 s_tinode;
+ __fs16 s_interleave_m;
+ __fs16 s_interleave_n;
+ char s_fname[6];
+ char s_fpack[6];
+ __fs32 s_unique;
+};
+
+
+struct sysv_inode {
+ __fs16 i_mode;
+ __fs16 i_nlink;
+ __fs16 i_uid;
+ __fs16 i_gid;
+ __fs32 i_size;
+ u8 i_data[3*(10+1+1+1)];
+ u8 i_gen;
+ __fs32 i_atime;
+ __fs32 i_mtime;
+ __fs32 i_ctime;
+};
+
+
+
+struct sysv_dir_entry {
+ sysv_ino_t inode;
+ char name[14];
+};
+# 10 "fs/sysv/sysv.h" 2
+# 21 "fs/sysv/sysv.h"
+struct sysv_sb_info {
+ struct super_block *s_sb;
+ int s_type;
+ char s_bytesex;
+ char s_truncate;
+
+ nlink_t s_link_max;
+ unsigned int s_inodes_per_block;
+ unsigned int s_inodes_per_block_1;
+ unsigned int s_inodes_per_block_bits;
+ unsigned int s_ind_per_block;
+ unsigned int s_ind_per_block_bits;
+ unsigned int s_ind_per_block_2;
+ unsigned int s_toobig_block;
+ unsigned int s_block_base;
+ unsigned short s_fic_size;
+ unsigned short s_flc_size;
+
+ struct buffer_head *s_bh1;
+ struct buffer_head *s_bh2;
+
+
+ char * s_sbd1;
+ char * s_sbd2;
+ __fs16 *s_sb_fic_count;
+        sysv_ino_t *s_sb_fic_inodes;
+ __fs16 *s_sb_total_free_inodes;
+ __fs16 *s_bcache_count;
+ sysv_zone_t *s_bcache;
+ __fs32 *s_free_blocks;
+ __fs32 *s_sb_time;
+ __fs32 *s_sb_state;
+
+
+ u32 s_firstinodezone;
+ u32 s_firstdatazone;
+ u32 s_ninodes;
+ u32 s_ndatazones;
+ u32 s_nzones;
+ u16 s_namelen;
+ int s_forced_ro;
+};
+
+
+
+
+struct sysv_inode_info {
+ __fs32 i_data[13];
+ u32 i_dir_start_lookup;
+ struct inode vfs_inode;
+};
+
+
+static inline __attribute__((always_inline)) struct sysv_inode_info *SYSV_I(struct inode *inode)
+{
+ return ({ const typeof( ((struct sysv_inode_info *)0)->vfs_inode ) *__mptr = (inode); (struct sysv_inode_info *)( (char *)__mptr - __builtin_offsetof(struct sysv_inode_info,vfs_inode) );});
+}
+
+static inline __attribute__((always_inline)) struct sysv_sb_info *SYSV_SB(struct super_block *sb)
+{
+ return sb->s_fs_info;
+}
+
+
+
+enum {
+ FSTYPE_NONE = 0,
+ FSTYPE_XENIX,
+ FSTYPE_SYSV4,
+ FSTYPE_SYSV2,
+ FSTYPE_COH,
+ FSTYPE_V7,
+ FSTYPE_AFS,
+ FSTYPE_END,
+};
+# 106 "fs/sysv/sysv.h"
+enum {
+ XENIX_LINK_MAX = 126,
+ SYSV_LINK_MAX = 126,
+ V7_LINK_MAX = 126,
+ COH_LINK_MAX = 10000,
+};
+
+
+static inline __attribute__((always_inline)) void dirty_sb(struct super_block *sb)
+{
+ struct sysv_sb_info *sbi = SYSV_SB(sb);
+
+ mark_buffer_dirty(sbi->s_bh1);
+ if (sbi->s_bh1 != sbi->s_bh2)
+  mark_buffer_dirty(sbi->s_bh2);
+ sb->s_dirt = 1;
+}
+
+
+
+extern struct sysv_inode *sysv_raw_inode(struct super_block *, unsigned,
+   struct buffer_head **);
+extern struct inode * sysv_new_inode(const struct inode *, mode_t);
+extern void sysv_free_inode(struct inode *);
+extern unsigned long sysv_count_free_inodes(struct super_block *);
+
+
+extern sysv_zone_t sysv_new_block(struct super_block *);
+extern void sysv_free_block(struct super_block *, sysv_zone_t);
+extern unsigned long sysv_count_free_blocks(struct super_block *);
+
+
+extern void sysv_truncate(struct inode *);
+extern int __sysv_write_begin(struct file *file, struct address_space *mapping,
+   loff_t pos, unsigned len, unsigned flags,
+   struct page **pagep, void **fsdata);
+
+
+extern struct inode *sysv_iget(struct super_block *, unsigned int);
+extern int sysv_write_inode(struct inode *, int);
+extern int sysv_sync_inode(struct inode *);
+extern void sysv_set_inode(struct inode *, dev_t);
+extern int sysv_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+extern int sysv_init_icache(void);
+extern void sysv_destroy_icache(void);
+
+
+
+extern struct sysv_dir_entry *sysv_find_entry(struct dentry *, struct page **);
+extern int sysv_add_link(struct dentry *, struct inode *);
+extern int sysv_delete_entry(struct sysv_dir_entry *, struct page *);
+extern int sysv_make_empty(struct inode *, struct inode *);
+extern int sysv_empty_dir(struct inode *);
+extern void sysv_set_link(struct sysv_dir_entry *, struct page *,
+   struct inode *);
+extern struct sysv_dir_entry *sysv_dotdot(struct inode *, struct page **);
+extern ino_t sysv_inode_by_name(struct dentry *);
+
+
+extern const struct inode_operations sysv_file_inode_operations;
+extern const struct inode_operations sysv_dir_inode_operations;
+extern const struct inode_operations sysv_fast_symlink_inode_operations;
+extern const struct file_operations sysv_file_operations;
+extern const struct file_operations sysv_dir_operations;
+extern const struct address_space_operations sysv_aops;
+extern const struct super_operations sysv_sops;
+extern const struct dentry_operations sysv_dentry_operations;
+
+
+enum {
+ BYTESEX_LE,
+ BYTESEX_PDP,
+ BYTESEX_BE,
+};
+
+static inline __attribute__((always_inline)) u32 PDP_swab(u32 x)
+{
+
+ return ((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16);
+
+
+
+
+
+
+
+}
+
+static inline __attribute__((always_inline)) __u32 fs32_to_cpu(struct sysv_sb_info *sbi, __fs32 n)
+{
+ if (sbi->s_bytesex == BYTESEX_PDP)
+  return PDP_swab(( __u32)n);
+ else if (sbi->s_bytesex == BYTESEX_LE)
+  return (( __u32)(__le32)(( __le32)n));
+ else
+  return (__builtin_constant_p((__u32)(( __u32)(__be32)(( __be32)n))) ? ((__u32)( (((__u32)(( __u32)(__be32)(( __be32)n)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(( __be32)n)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(( __be32)n)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(( __be32)n)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(( __be32)n)));
+}
+
+static inline __attribute__((always_inline)) __fs32 cpu_to_fs32(struct sysv_sb_info *sbi, __u32 n)
+{
+ if (sbi->s_bytesex == BYTESEX_PDP)
+  return ( __fs32)PDP_swab(n);
+ else if (sbi->s_bytesex == BYTESEX_LE)
+  return ( __fs32)(( __le32)(__u32)(n));
+ else
+  return ( __fs32)(( __be32)(__builtin_constant_p((__u32)((n))) ? ((__u32)( (((__u32)((n)) & (__u32)0x000000ffUL) << 24) | (((__u32)((n)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((n)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((n)) & (__u32)0xff000000UL) >> 24))) : __fswab32((n))));
+}
+
+static inline __attribute__((always_inline)) __fs32 fs32_add(struct sysv_sb_info *sbi, __fs32 *n, int d)
+{
+ if (sbi->s_bytesex == BYTESEX_PDP)
+  *(__u32*)n = PDP_swab(PDP_swab(*(__u32*)n)+d);
+ else if (sbi->s_bytesex == BYTESEX_LE)
+  le32_add_cpu((__le32 *)n, d);
+ else
+  be32_add_cpu((__be32 *)n, d);
+ return *n;
+}
+
+static inline __attribute__((always_inline)) __u16 fs16_to_cpu(struct sysv_sb_info *sbi, __fs16 n)
+{
+ if (sbi->s_bytesex != BYTESEX_BE)
+  return (( __u16)(__le16)(( __le16)n));
+ else
+  return (__builtin_constant_p((__u16)(( __u16)(__be16)(( __be16)n))) ? ((__u16)( (((__u16)(( __u16)(__be16)(( __be16)n)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(( __be16)n)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(( __be16)n)));
+}
+
+static inline __attribute__((always_inline)) __fs16 cpu_to_fs16(struct sysv_sb_info *sbi, __u16 n)
+{
+ if (sbi->s_bytesex != BYTESEX_BE)
+  return ( __fs16)(( __le16)(__u16)(n));
+ else
+  return ( __fs16)(( __be16)(__builtin_constant_p((__u16)((n))) ? ((__u16)( (((__u16)((n)) & (__u16)0x00ffU) << 8) | (((__u16)((n)) & (__u16)0xff00U) >> 8))) : __fswab16((n))));
+}
+
+static inline __attribute__((always_inline)) __fs16 fs16_add(struct sysv_sb_info *sbi, __fs16 *n, int d)
+{
+ if (sbi->s_bytesex != BYTESEX_BE)
+  le16_add_cpu((__le16 *)n, d);
+ else
+  be16_add_cpu((__be16 *)n, d);
+ return *n;
+}
+# 28 "fs/sysv/super.c" 2
+# 43 "fs/sysv/super.c"
+enum {
+ JAN_1_1980 = (10*365 + 2) * 24 * 60 * 60
+};
+
+static void detected_xenix(struct sysv_sb_info *sbi)
+{
+ struct buffer_head *bh1 = sbi->s_bh1;
+ struct buffer_head *bh2 = sbi->s_bh2;
+ struct xenix_super_block * sbd1;
+ struct xenix_super_block * sbd2;
+
+ if (bh1 != bh2)
+  sbd1 = sbd2 = (struct xenix_super_block *) bh1->b_data;
+ else {
+
+  sbd1 = (struct xenix_super_block *) bh1->b_data;
+  sbd2 = (struct xenix_super_block *) (bh2->b_data - 512);
+ }
+
+ sbi->s_link_max = XENIX_LINK_MAX;
+ sbi->s_fic_size = 100;
+ sbi->s_flc_size = 100;
+ sbi->s_sbd1 = (char *)sbd1;
+ sbi->s_sbd2 = (char *)sbd2;
+ sbi->s_sb_fic_count = &sbd1->s_ninode;
+ sbi->s_sb_fic_inodes = &sbd1->s_inode[0];
+ sbi->s_sb_total_free_inodes = &sbd2->s_tinode;
+ sbi->s_bcache_count = &sbd1->s_nfree;
+ sbi->s_bcache = &sbd1->s_free[0];
+ sbi->s_free_blocks = &sbd2->s_tfree;
+ sbi->s_sb_time = &sbd2->s_time;
+ sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd1->s_isize);
+ sbi->s_nzones = fs32_to_cpu(sbi, sbd1->s_fsize);
+}
+
+static void detected_sysv4(struct sysv_sb_info *sbi)
+{
+ struct sysv4_super_block * sbd;
+ struct buffer_head *bh1 = sbi->s_bh1;
+ struct buffer_head *bh2 = sbi->s_bh2;
+
+ if (bh1 == bh2)
+  sbd = (struct sysv4_super_block *) (bh1->b_data + (1<<10)/2);
+ else
+  sbd = (struct sysv4_super_block *) bh2->b_data;
+
+ sbi->s_link_max = SYSV_LINK_MAX;
+ sbi->s_fic_size = 100;
+ sbi->s_flc_size = 50;
+ sbi->s_sbd1 = (char *)sbd;
+ sbi->s_sbd2 = (char *)sbd;
+ sbi->s_sb_fic_count = &sbd->s_ninode;
+ sbi->s_sb_fic_inodes = &sbd->s_inode[0];
+ sbi->s_sb_total_free_inodes = &sbd->s_tinode;
+ sbi->s_bcache_count = &sbd->s_nfree;
+ sbi->s_bcache = &sbd->s_free[0];
+ sbi->s_free_blocks = &sbd->s_tfree;
+ sbi->s_sb_time = &sbd->s_time;
+ sbi->s_sb_state = &sbd->s_state;
+ sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
+ sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
+}
+
+static void detected_sysv2(struct sysv_sb_info *sbi)
+{
+ struct sysv2_super_block *sbd;
+ struct buffer_head *bh1 = sbi->s_bh1;
+ struct buffer_head *bh2 = sbi->s_bh2;
+
+ if (bh1 == bh2)
+  sbd = (struct sysv2_super_block *) (bh1->b_data + (1<<10)/2);
+ else
+  sbd = (struct sysv2_super_block *) bh2->b_data;
+
+ sbi->s_link_max = SYSV_LINK_MAX;
+ sbi->s_fic_size = 100;
+ sbi->s_flc_size = 50;
+ sbi->s_sbd1 = (char *)sbd;
+ sbi->s_sbd2 = (char *)sbd;
+ sbi->s_sb_fic_count = &sbd->s_ninode;
+ sbi->s_sb_fic_inodes = &sbd->s_inode[0];
+ sbi->s_sb_total_free_inodes = &sbd->s_tinode;
+ sbi->s_bcache_count = &sbd->s_nfree;
+ sbi->s_bcache = &sbd->s_free[0];
+ sbi->s_free_blocks = &sbd->s_tfree;
+ sbi->s_sb_time = &sbd->s_time;
+ sbi->s_sb_state = &sbd->s_state;
+ sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
+ sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
+}
+
+static void detected_coherent(struct sysv_sb_info *sbi)
+{
+ struct coh_super_block * sbd;
+ struct buffer_head *bh1 = sbi->s_bh1;
+
+ sbd = (struct coh_super_block *) bh1->b_data;
+
+ sbi->s_link_max = COH_LINK_MAX;
+ sbi->s_fic_size = 100;
+ sbi->s_flc_size = 64;
+ sbi->s_sbd1 = (char *)sbd;
+ sbi->s_sbd2 = (char *)sbd;
+ sbi->s_sb_fic_count = &sbd->s_ninode;
+ sbi->s_sb_fic_inodes = &sbd->s_inode[0];
+ sbi->s_sb_total_free_inodes = &sbd->s_tinode;
+ sbi->s_bcache_count = &sbd->s_nfree;
+ sbi->s_bcache = &sbd->s_free[0];
+ sbi->s_free_blocks = &sbd->s_tfree;
+ sbi->s_sb_time = &sbd->s_time;
+ sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
+ sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
+}
+
+static void detected_v7(struct sysv_sb_info *sbi)
+{
+ struct buffer_head *bh2 = sbi->s_bh2;
+ struct v7_super_block *sbd = (struct v7_super_block *)bh2->b_data;
+
+ sbi->s_link_max = V7_LINK_MAX;
+ sbi->s_fic_size = 100;
+ sbi->s_flc_size = 50;
+ sbi->s_sbd1 = (char *)sbd;
+ sbi->s_sbd2 = (char *)sbd;
+ sbi->s_sb_fic_count = &sbd->s_ninode;
+ sbi->s_sb_fic_inodes = &sbd->s_inode[0];
+ sbi->s_sb_total_free_inodes = &sbd->s_tinode;
+ sbi->s_bcache_count = &sbd->s_nfree;
+ sbi->s_bcache = &sbd->s_free[0];
+ sbi->s_free_blocks = &sbd->s_tfree;
+ sbi->s_sb_time = &sbd->s_time;
+ sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
+ sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
+}
+
+static int detect_xenix(struct sysv_sb_info *sbi, struct buffer_head *bh)
+{
+ struct xenix_super_block *sbd = (struct xenix_super_block *)bh->b_data;
+ if (*(__le32 *)&sbd->s_magic == (( __le32)(__u32)(0x2b5544)))
+  sbi->s_bytesex = BYTESEX_LE;
+ else if (*(__be32 *)&sbd->s_magic == (( __be32)(__builtin_constant_p((__u32)((0x2b5544))) ? ((__u32)( (((__u32)((0x2b5544)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0x2b5544)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0x2b5544)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0x2b5544)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0x2b5544)))))
+  sbi->s_bytesex = BYTESEX_BE;
+ else
+  return 0;
+ switch (fs32_to_cpu(sbi, sbd->s_type)) {
+ case 1:
+  sbi->s_type = FSTYPE_XENIX;
+  return 1;
+ case 2:
+  sbi->s_type = FSTYPE_XENIX;
+  return 2;
+ default:
+  return 0;
+ }
+}
+
+static int detect_sysv(struct sysv_sb_info *sbi, struct buffer_head *bh)
+{
+ struct super_block *sb = sbi->s_sb;
+
+ struct sysv4_super_block * sbd;
+ u32 type;
+
+ sbd = (struct sysv4_super_block *) (bh->b_data + (1<<10)/2);
+ if (*(__le32 *)&sbd->s_magic == (( __le32)(__u32)(0xfd187e20)))
+  sbi->s_bytesex = BYTESEX_LE;
+ else if (*(__be32 *)&sbd->s_magic == (( __be32)(__builtin_constant_p((__u32)((0xfd187e20))) ? ((__u32)( (((__u32)((0xfd187e20)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xfd187e20)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xfd187e20)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xfd187e20)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xfd187e20)))))
+  sbi->s_bytesex = BYTESEX_BE;
+ else
+  return 0;
+
+ type = fs32_to_cpu(sbi, sbd->s_type);
+
+  if (fs16_to_cpu(sbi, sbd->s_nfree) == 0xffff) {
+   sbi->s_type = FSTYPE_AFS;
+  sbi->s_forced_ro = 1;
+   if (!(sb->s_flags & 1)) {
+    printk("SysV FS: SCO EAFS on %s detected, "
+     "forcing read-only mode.\n",
+     sb->s_id);
+   }
+   return type;
+  }
+
+ if (fs32_to_cpu(sbi, sbd->s_time) < JAN_1_1980) {
+
+  if (type > 3 || type < 1)
+   return 0;
+  sbi->s_type = FSTYPE_SYSV2;
+  return type;
+ }
+ if ((type > 3 || type < 1) && (type > 0x30 || type < 0x10))
+  return 0;
+
+
+
+
+
+
+ if (type >= 0x10) {
+  printk("SysV FS: can't handle long file names on %s, "
+         "forcing read-only mode.\n", sb->s_id);
+  sbi->s_forced_ro = 1;
+ }
+
+ sbi->s_type = FSTYPE_SYSV4;
+ return type >= 0x10 ? type >> 4 : type;
+}
+
+static int detect_coherent(struct sysv_sb_info *sbi, struct buffer_head *bh)
+{
+ struct coh_super_block * sbd;
+
+ sbd = (struct coh_super_block *) (bh->b_data + (1<<10)/2);
+ if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))
+     || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))
+  return 0;
+ sbi->s_bytesex = BYTESEX_PDP;
+ sbi->s_type = FSTYPE_COH;
+ return 1;
+}
+
+static int detect_sysv_odd(struct sysv_sb_info *sbi, struct buffer_head *bh)
+{
+ int size = detect_sysv(sbi, bh);
+
+ return size>2 ? 0 : size;
+}
+
+static struct {
+ int block;
+ int (*test)(struct sysv_sb_info *, struct buffer_head *);
+} flavours[] = {
+ {1, detect_xenix},
+ {0, detect_sysv},
+ {0, detect_coherent},
+ {9, detect_sysv_odd},
+ {15,detect_sysv_odd},
+ {18,detect_sysv},
+};
+
+static char *flavour_names[] = {
+ [FSTYPE_XENIX] = "Xenix",
+ [FSTYPE_SYSV4] = "SystemV",
+ [FSTYPE_SYSV2] = "SystemV Release 2",
+ [FSTYPE_COH] = "Coherent",
+ [FSTYPE_V7] = "V7",
+ [FSTYPE_AFS] = "AFS",
+};
+
+static void (*flavour_setup[])(struct sysv_sb_info *) = {
+ [FSTYPE_XENIX] = detected_xenix,
+ [FSTYPE_SYSV4] = detected_sysv4,
+ [FSTYPE_SYSV2] = detected_sysv2,
+ [FSTYPE_COH] = detected_coherent,
+ [FSTYPE_V7] = detected_v7,
+ [FSTYPE_AFS] = detected_sysv4,
+};
+
+static int complete_read_super(struct super_block *sb, int silent, int size)
+{
+ struct sysv_sb_info *sbi = SYSV_SB(sb);
+ struct inode *root_inode;
+ char *found = flavour_names[sbi->s_type];
+ u_char n_bits = size+8;
+ int bsize = 1 << n_bits;
+ int bsize_4 = bsize >> 2;
+
+ sbi->s_firstinodezone = 2;
+
+ flavour_setup[sbi->s_type](sbi);
+
+ sbi->s_truncate = 1;
+ sbi->s_ndatazones = sbi->s_nzones - sbi->s_firstdatazone;
+ sbi->s_inodes_per_block = bsize >> 6;
+ sbi->s_inodes_per_block_1 = (bsize >> 6)-1;
+ sbi->s_inodes_per_block_bits = n_bits-6;
+ sbi->s_ind_per_block = bsize_4;
+ sbi->s_ind_per_block_2 = bsize_4*bsize_4;
+ sbi->s_toobig_block = 10 + bsize_4 * (1 + bsize_4 * (1 + bsize_4));
+ sbi->s_ind_per_block_bits = n_bits-2;
+
+ sbi->s_ninodes = (sbi->s_firstdatazone - sbi->s_firstinodezone)
+  << sbi->s_inodes_per_block_bits;
+
+ if (!silent)
+  printk("VFS: Found a %s FS (block size = %ld) on device %s\n",
+         found, sb->s_blocksize, sb->s_id);
+
+ sb->s_magic = 0x012FF7B3 + sbi->s_type;
+
+ sb->s_op = &sysv_sops;
+ root_inode = sysv_iget(sb, 2);
+ if (IS_ERR(root_inode)) {
+  printk("SysV FS: get root inode failed\n");
+  return 0;
+ }
+ sb->s_root = d_alloc_root(root_inode);
+ if (!sb->s_root) {
+  iput(root_inode);
+  printk("SysV FS: get root dentry failed\n");
+  return 0;
+ }
+ if (sbi->s_forced_ro)
+  sb->s_flags |= 1;
+ if (sbi->s_truncate)
+  sb->s_root->d_op = &sysv_dentry_operations;
+ sb->s_dirt = 1;
+ return 1;
+}
+
+static int sysv_fill_super(struct super_block *sb, void *data, int silent)
+{
+ struct buffer_head *bh1, *bh = ((void *)0);
+ struct sysv_sb_info *sbi;
+ unsigned long blocknr;
+ int size = 0, i;
+
+ ((void)(sizeof(struct { int:-!!(1024 != sizeof (struct xenix_super_block)); })));
+ ((void)(sizeof(struct { int:-!!(512 != sizeof (struct sysv4_super_block)); })));
+ ((void)(sizeof(struct { int:-!!(512 != sizeof (struct sysv2_super_block)); })));
+ ((void)(sizeof(struct { int:-!!(500 != sizeof (struct coh_super_block)); })));
+ ((void)(sizeof(struct { int:-!!(64 != sizeof (struct sysv_inode)); })));
+
+ sbi = kzalloc(sizeof(struct sysv_sb_info), ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
+ if (!sbi)
+  return -12;
+
+ sbi->s_sb = sb;
+ sbi->s_block_base = 0;
+ sb->s_fs_info = sbi;
+
+ sb_set_blocksize(sb, (1<<10));
+
+ for (i = 0; i < (sizeof(flavours) / sizeof((flavours)[0]) + (sizeof(struct { int:-!!(__builtin_types_compatible_p(typeof(flavours), typeof(&flavours[0]))); }))) && !size; i++) {
+  brelse(bh);
+  bh = sb_bread(sb, flavours[i].block);
+  if (!bh)
+   continue;
+  size = flavours[i].test(SYSV_SB(sb), bh);
+ }
+
+ if (!size)
+  goto Eunknown;
+
+ switch (size) {
+  case 1:
+   blocknr = bh->b_blocknr << 1;
+   brelse(bh);
+   sb_set_blocksize(sb, 512);
+   bh1 = sb_bread(sb, blocknr);
+   bh = sb_bread(sb, blocknr + 1);
+   break;
+  case 2:
+   bh1 = bh;
+   break;
+  case 3:
+   blocknr = bh->b_blocknr >> 1;
+   brelse(bh);
+   sb_set_blocksize(sb, 2048);
+   bh1 = bh = sb_bread(sb, blocknr);
+   break;
+  default:
+   goto Ebadsize;
+ }
+
+ if (bh && bh1) {
+  sbi->s_bh1 = bh1;
+  sbi->s_bh2 = bh;
+  if (complete_read_super(sb, silent, size))
+   return 0;
+ }
+
+ brelse(bh1);
+ brelse(bh);
+ sb_set_blocksize(sb, (1<<10));
+ printk("oldfs: cannot read superblock\n");
+failed:
+ kfree(sbi);
+ return -22;
+
+Eunknown:
+ brelse(bh);
+ if (!silent)
+  printk("VFS: unable to find oldfs superblock on device %s\n",
+   sb->s_id);
+ goto failed;
+Ebadsize:
+ brelse(bh);
+ if (!silent)
+  printk("VFS: oldfs: unsupported block size (%dKb)\n",
+   1<<(size-2));
+ goto failed;
+}
+
+static int v7_fill_super(struct super_block *sb, void *data, int silent)
+{
+ struct sysv_sb_info *sbi;
+ struct buffer_head *bh, *bh2 = ((void *)0);
+ struct v7_super_block *v7sb;
+ struct sysv_inode *v7i;
+
+ if (440 != sizeof (struct v7_super_block))
+  panic("V7 FS: bad super-block size");
+ if (64 != sizeof (struct sysv_inode))
+  panic("sysv fs: bad i-node size");
+
+ sbi = kzalloc(sizeof(struct sysv_sb_info), ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
+ if (!sbi)
+  return -12;
+
+ sbi->s_sb = sb;
+ sbi->s_block_base = 0;
+ sbi->s_type = FSTYPE_V7;
+ sbi->s_bytesex = BYTESEX_PDP;
+ sb->s_fs_info = sbi;
+
+ sb_set_blocksize(sb, 512);
+
+ if ((bh = sb_bread(sb, 1)) == ((void *)0)) {
+  if (!silent)
+   printk("VFS: unable to read V7 FS superblock on "
+          "device %s.\n", sb->s_id);
+  goto failed;
+ }
+
+
+ v7sb = (struct v7_super_block *) bh->b_data;
+ if (fs16_to_cpu(sbi, v7sb->s_nfree) > 50 ||
+     fs16_to_cpu(sbi, v7sb->s_ninode) > 100 ||
+     fs32_to_cpu(sbi, v7sb->s_time) == 0)
+  goto failed;
+
+
+
+ if ((bh2 = sb_bread(sb, 2)) == ((void *)0))
+  goto failed;
+ v7i = (struct sysv_inode *)(bh2->b_data + 64);
+ if ((fs16_to_cpu(sbi, v7i->i_mode) & ~0777) != 0040000 ||
+     (fs32_to_cpu(sbi, v7i->i_size) == 0) ||
+     (fs32_to_cpu(sbi, v7i->i_size) & 017) != 0)
+  goto failed;
+ brelse(bh2);
+ bh2 = ((void *)0);
+
+ sbi->s_bh1 = bh;
+ sbi->s_bh2 = bh;
+ if (complete_read_super(sb, silent, 1))
+  return 0;
+
+failed:
+ brelse(bh2);
+ brelse(bh);
+ kfree(sbi);
+ return -22;
+}
+
+
+
+static int sysv_get_sb(struct file_system_type *fs_type,
+ int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+{
+ return get_sb_bdev(fs_type, flags, dev_name, data, sysv_fill_super,
+      mnt);
+}
+
+static int v7_get_sb(struct file_system_type *fs_type,
+ int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+{
+ return get_sb_bdev(fs_type, flags, dev_name, data, v7_fill_super, mnt);
+}
+
+static struct file_system_type sysv_fs_type = {
+ .owner = (&__this_module),
+ .name = "sysv",
+ .get_sb = sysv_get_sb,
+ .kill_sb = kill_block_super,
+ .fs_flags = 1,
+};
+
+static struct file_system_type v7_fs_type = {
+ .owner = (&__this_module),
+ .name = "v7",
+ .get_sb = v7_get_sb,
+ .kill_sb = kill_block_super,
+ .fs_flags = 1,
+};
+
+static int __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) init_sysv_fs(void)
+{
+ int error;
+
+ error = sysv_init_icache();
+ if (error)
+  goto out;
+ error = register_filesystem(&sysv_fs_type);
+ if (error)
+  goto destroy_icache;
+ error = register_filesystem(&v7_fs_type);
+ if (error)
+  goto unregister;
+ return 0;
+
+unregister:
+ unregister_filesystem(&sysv_fs_type);
+destroy_icache:
+ sysv_destroy_icache();
+out:
+ return error;
+}
+
+static void __attribute__ ((__section__(".exit.text"))) __attribute__((__cold__)) exit_sysv_fs(void)
+{
+ unregister_filesystem(&sysv_fs_type);
+ unregister_filesystem(&v7_fs_type);
+ sysv_destroy_icache();
+}
+
+static inline __attribute__((always_inline)) initcall_t __inittest(void) { return init_sysv_fs; } int init_module(void) __attribute__((alias("init_sysv_fs")));
+static inline __attribute__((always_inline)) exitcall_t __exittest(void) { return exit_sysv_fs; } void cleanup_module(void) __attribute__((alias("exit_sysv_fs")));
+static const char __mod_license563[] __attribute__((__used__)) __attribute__((section(".modinfo"),unused)) = "license" "=" "GPL";

diff --git a/bfin-5761/super.i.1 b/bfin-5761/super.i.1
new file mode 100644 (file)
index 0000000..3c87c95
--- /dev/null
+++ b/bfin-5761/super.i.1
@@ -0,0 +1,67 @@
+typedef unsigned long long u64;
+typedef u64 sector_t;
+extern struct module __this_module;
+struct super_block {
+       unsigned long s_blocksize;
+       struct block_device *s_bdev;
+};
+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;
+};
+void kill_block_super(struct super_block *sb);
+struct buffer_head {
+       sector_t b_blocknr;
+};
+static inline __attribute__ ((always_inline))
+struct buffer_head *sb_bread(struct super_block *sb, sector_t block)
+{
+       return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+static int detect_sysv(struct sysv_sb_info *sbi, struct buffer_head *bh)
+{
+}
+static struct {
+       int (*test) (struct sysv_sb_info *, struct buffer_head *);
+} flavours[] = {
+       {
+       0, detect_sysv}
+,};
+static int sysv_fill_super(struct super_block *sb, void *data, int silent)
+{
+       struct buffer_head *bh1, *bh = ((void *)0);
+       unsigned long blocknr;
+       int size = 0, i;
+       for (i = 0; i < (sizeof(flavours) / sizeof((flavours)[0]) + (sizeof(struct {
+                                                                           }
+                                                                    )))
+            && !size; i++) {
+               size = flavours[i].test(SYSV_SB(sb), bh);
+       }
+       switch (size) {
+       case 3:
+               blocknr = bh->b_blocknr >> 1;
+               bh1 = bh = sb_bread(sb, blocknr);
+       }
+}
+static int sysv_get_sb(struct file_system_type *fs_type, int flags,
+                      const char *dev_name, void *data, struct vfsmount *mnt)
+{
+       return get_sb_bdev(fs_type, flags, dev_name, data, sysv_fill_super,
+                          mnt);
+}
+static struct file_system_type sysv_fs_type = {
+       .owner = (&__this_module),.name = "sysv",.get_sb =
+           sysv_get_sb,.kill_sb = kill_block_super,.fs_flags = 1,
+};
+static int __attribute__ ((__section__(".init.text")))
+    __attribute__ ((__cold__))
+    __attribute__ ((no_instrument_function)) init_sysv_fs(void)
+{
+      unregister:unregister_filesystem(&sysv_fs_type);
+}
+int init_module(void) __attribute__ ((alias("init_sysv_fs")));

diff --git a/bfin-5761/super.i.2 b/bfin-5761/super.i.2
new file mode 100644 (file)
index 0000000..dce8e74
--- /dev/null
+++ b/bfin-5761/super.i.2
@@ -0,0 +1,40 @@
+typedef unsigned long long u64;
+struct super_block {
+       unsigned long s_blocksize;
+       struct block_device *s_bdev;
+};
+struct buffer_head {
+       u64 b_blocknr;
+};
+struct buffer_head *sb_bread(struct super_block *sb, u64 block)
+{
+       return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+int detect_sysv(struct sysv_sb_info *sbi, struct buffer_head *bh)
+{
+}
+struct {
+       int (*test) (struct sysv_sb_info *, struct buffer_head *);
+} flavours[] = {
+       {
+       0, detect_sysv}
+,};
+int sysv_fill_super(struct super_block *sb, void *data, int silent)
+{
+       struct buffer_head *bh1;
+       struct buffer_head *bh = ((void *)0);
+       unsigned long blocknr;
+       int size = 0;
+       int i;
+       for (i = 0; i < (sizeof(flavours) / sizeof((flavours)[0]) + (sizeof(struct {
+                                                                           }
+                                                                    )))
+            && !size; i++) {
+               size = flavours[i].test(SYSV_SB(sb), bh);
+       }
+       switch (size) {
+       case 3:
+               blocknr = bh->b_blocknr >> 1;
+               bh1 = bh = sb_bread(sb, blocknr);
+       }
+}

diff --git a/bfin-5761/super.i.3 b/bfin-5761/super.i.3
new file mode 100644 (file)
index 0000000..0a89a8f
--- /dev/null
+++ b/bfin-5761/super.i.3
@@ -0,0 +1,31 @@
+typedef unsigned long long u64;
+struct super_block {
+       unsigned long s_blocksize;
+       struct block_device *s_bdev;
+};
+struct buffer_head {
+       u64 b_blocknr;
+};
+struct buffer_head *sb_bread(struct super_block *sb, u64 block)
+{
+       return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+
+struct {
+       int (*test) (struct sysv_sb_info *, struct buffer_head *);
+} flavours[] = {
+};
+int sysv_fill_super(struct super_block *sb, void *data, int silent)
+{
+       struct buffer_head *bh = 0;
+       unsigned long blocknr;
+       int size = 0;
+       int i;
+       for (i = 0; i < 1 && !size; i++)
+               size = flavours[i].test(SYSV_SB(sb), bh);
+       switch (size) {
+       case 3:
+               blocknr = bh->b_blocknr >> 1;
+               bh = sb_bread(sb, blocknr);
+       }
+}

diff --git a/bfin-5761/super.i.4 b/bfin-5761/super.i.4
new file mode 100644 (file)
index 0000000..95392af
--- /dev/null
+++ b/bfin-5761/super.i.4
@@ -0,0 +1,26 @@
+typedef unsigned long long u64;
+struct super_block {
+       unsigned long s_blocksize;
+       struct block_device *s_bdev;
+};
+struct buffer_head {
+       u64 b_blocknr;
+};
+int sb_bread(struct super_block *sb, u64 block)
+{
+       return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+
+struct {
+       int (*test) (struct sysv_sb_info *, struct buffer_head *);
+} flavours[];
+int sysv_fill_super(struct super_block *sb)
+{
+       struct buffer_head *bh = 0;
+       unsigned long blocknr;
+       switch (test(sb, bh)) {
+       case 3:
+               blocknr = bh->b_blocknr >> 1;
+               bh = sb_bread(sb, blocknr);
+       }
+}

diff --git a/bfin-5761/super.i.5 b/bfin-5761/super.i.5
new file mode 100644 (file)
index 0000000..6980f09
--- /dev/null
+++ b/bfin-5761/super.i.5
@@ -0,0 +1,21 @@
+typedef unsigned long long u64;
+struct super_block {
+       unsigned s_blocksize;
+       struct block_device *s_bdev;
+};
+struct buffer_head {
+       u64 b_blocknr;
+};
+int sb_bread(struct super_block *sb, u64 block)
+{
+       return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+int sysv_fill_super(struct super_block *sb)
+{
+       struct buffer_head *bh;
+       unsigned blocknr;
+       if (test()) {
+               blocknr = bh->b_blocknr >> 1;
+               bh = sb_bread(sb, blocknr);
+       }
+}

diff --git a/bfin-5761/super.i.6 b/bfin-5761/super.i.6
new file mode 100644 (file)
index 0000000..0ff31ce
--- /dev/null
+++ b/bfin-5761/super.i.6
@@ -0,0 +1,19 @@
+typedef unsigned long long u64;
+struct super_block {
+       unsigned s_blocksize;
+       void *s_bdev;
+};
+struct buffer_head {
+       u64 b_blocknr;
+};
+sb_bread(struct super_block *sb, u64 block)
+{
+       __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+sysv_fill_super(struct super_block *sb)
+{
+       struct buffer_head *bh;
+       unsigned blocknr;
+       blocknr = bh->b_blocknr >> 1;
+       sb_bread(sb, blocknr);
+}