GCC compile error

gistfile1.c

// /usr/lib/gcc-cross/arm-linux-gnueabi/4.7/cc1 -quiet -nostdinc -I ./arch/arm/include -I arch/arm/include/generated/uapi -I arch/arm/include/generated -I include -I ./arch/arm/include/uapi -I arch/arm/include/generated/uapi -I ./include/uapi -I include/generated/uapi -imultilib sf -imultiarch arm-linux-gnueabi -D __KERNEL__ -D __LINUX_ARM_ARCH__=7 -U arm -D CC_HAVE_ASM_GOTO -D KBUILD_STR(s)=#s -D KBUILD_BASENAME=KBUILD_STR(migrate) -D KBUILD_MODNAME=KBUILD_STR(migrate) -isystem /usr/lib/gcc-cross/arm-linux-gnueabi/4.7/include -include ./include/linux/kconfig.h -MD mm/.migrate.o.d mm/migrate.c -quiet -dumpbase migrate.c -mlittle-endian -mabi=aapcs-linux -mno-thumb-interwork -mfpu=vfp -marm -march=armv7-a -mfloat-abi=soft -mtls-dialect=gnu -auxbase-strip mm/migrate.o -g -O2 -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -Werror=implicit-function-declaration -Wno-format-security -Wframe-larger-than=1024 -Wno-unused-but-set-variable -Wdeclaration-after-statement -Wno-pointer-sign -Werror=implicit-int -Werror=strict-prototypes -std=gnu90 -fno-strict-aliasing -fno-common -fno-dwarf2-cfi-asm -funwind-tables -fno-delete-null-pointer-checks -fno-stack-protector -fomit-frame-pointer -fno-var-tracking-assignments -fno-strict-overflow -fconserve-stack --param allow-store-data-races=0 -o - -frandom-seed=0
# 1 "mm/migrate.c"
# 1 "/home/mkrawczuk/ksf/linux-next//"
# 1 "<command-line>"
# 1 "././include/linux/kconfig.h" 1



# 1 "include/generated/autoconf.h" 1
# 5 "././include/linux/kconfig.h" 2
# 1 "<command-line>" 2
# 1 "mm/migrate.c"
# 15 "mm/migrate.c"
# 1 "include/linux/migrate.h" 1



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



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



# 1 "include/uapi/linux/errno.h" 1
# 1 "arch/arm/include/generated/asm/errno.h" 1
# 1 "./include/uapi/asm-generic/errno.h" 1



# 1 "./include/uapi/asm-generic/errno-base.h" 1
# 5 "./include/uapi/asm-generic/errno.h" 2
# 1 "arch/arm/include/generated/asm/errno.h" 2
# 1 "include/uapi/linux/errno.h" 2
# 5 "include/linux/errno.h" 2
# 5 "include/linux/mm.h" 2



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



# 1 "include/linux/stringify.h" 1
# 5 "include/linux/mmdebug.h" 2

struct page;
struct vm_area_struct;
struct mm_struct;

extern void dump_page(struct page *page, const char *reason);
extern void dump_page_badflags(struct page *page, const char *reason,
          unsigned long badflags);
void dump_vma(const struct vm_area_struct *vma);
void dump_mm(const struct mm_struct *mm);
# 9 "include/linux/mm.h" 2
# 1 "include/linux/gfp.h" 1




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






# 1 "include/linux/spinlock.h" 1
# 49 "include/linux/spinlock.h"
# 1 "include/linux/typecheck.h" 1
# 50 "include/linux/spinlock.h" 2
# 1 "include/linux/preempt.h" 1
# 9 "include/linux/preempt.h"
# 1 "include/linux/linkage.h" 1



# 1 "include/linux/compiler.h" 1
# 54 "include/linux/compiler.h"
# 1 "include/linux/compiler-gcc.h" 1
# 107 "include/linux/compiler-gcc.h"
# 1 "include/linux/compiler-gcc4.h" 1
# 108 "include/linux/compiler-gcc.h" 2
# 55 "include/linux/compiler.h" 2
# 83 "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];
 };
};
# 193 "include/linux/compiler.h"
# 1 "include/uapi/linux/types.h" 1



# 1 "./arch/arm/include/asm/types.h" 1



# 1 "include/asm-generic/int-ll64.h" 1
# 10 "include/asm-generic/int-ll64.h"
# 1 "include/uapi/asm-generic/int-ll64.h" 1
# 11 "include/uapi/asm-generic/int-ll64.h"
# 1 "arch/arm/include/generated/asm/bitsperlong.h" 1
# 1 "include/asm-generic/bitsperlong.h" 1



# 1 "include/uapi/asm-generic/bitsperlong.h" 1
# 5 "include/asm-generic/bitsperlong.h" 2
# 1 "arch/arm/include/generated/asm/bitsperlong.h" 2
# 12 "include/uapi/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;
# 11 "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;

typedef signed long long s64;
typedef unsigned long long u64;
# 5 "./arch/arm/include/asm/types.h" 2
# 5 "include/uapi/linux/types.h" 2
# 13 "include/uapi/linux/types.h"
# 1 "./include/uapi/linux/posix_types.h" 1



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



# 1 "include/uapi/linux/stddef.h" 1
# 1 "include/linux/compiler.h" 1
# 1 "include/uapi/linux/stddef.h" 2
# 5 "include/linux/stddef.h" 2





enum {
 false = 0,
 true = 1
};
# 5 "./include/uapi/linux/posix_types.h" 2
# 24 "./include/uapi/linux/posix_types.h"
typedef struct {
 unsigned long fds_bits[1024 / (8 * sizeof(long))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;
typedef int __kernel_mqd_t;

# 1 "./arch/arm/include/uapi/asm/posix_types.h" 1
# 22 "./arch/arm/include/uapi/asm/posix_types.h"
typedef unsigned short __kernel_mode_t;


typedef unsigned short __kernel_ipc_pid_t;


typedef unsigned short __kernel_uid_t;
typedef unsigned short __kernel_gid_t;


typedef unsigned short __kernel_old_dev_t;


# 1 "./include/uapi/asm-generic/posix_types.h" 1



# 1 "arch/arm/include/generated/asm/bitsperlong.h" 1
# 5 "./include/uapi/asm-generic/posix_types.h" 2
# 14 "./include/uapi/asm-generic/posix_types.h"
typedef long __kernel_long_t;
typedef unsigned long __kernel_ulong_t;



typedef __kernel_ulong_t __kernel_ino_t;







typedef int __kernel_pid_t;
# 40 "./include/uapi/asm-generic/posix_types.h"
typedef __kernel_long_t __kernel_suseconds_t;



typedef int __kernel_daddr_t;



typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;



typedef __kernel_uid_t __kernel_old_uid_t;
typedef __kernel_gid_t __kernel_old_gid_t;
# 67 "./include/uapi/asm-generic/posix_types.h"
typedef unsigned int __kernel_size_t;
typedef int __kernel_ssize_t;
typedef int __kernel_ptrdiff_t;
# 78 "./include/uapi/asm-generic/posix_types.h"
typedef struct {
 int val[2];
} __kernel_fsid_t;





typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
typedef __kernel_long_t __kernel_time_t;
typedef __kernel_long_t __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;
# 36 "./arch/arm/include/uapi/asm/posix_types.h" 2
# 36 "./include/uapi/linux/posix_types.h" 2
# 14 "include/uapi/linux/types.h" 2
# 32 "include/uapi/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;
# 194 "include/linux/compiler.h" 2

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void data_access_exceeds_word_size(void)

__attribute__((warning("data access exceeds word size and won't be atomic")))

;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void data_access_exceeds_word_size(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void __read_once_size(const volatile void *p, void *res, int size)
{
 switch (size) {
 case 1: *(__u8 *)res = *(volatile __u8 *)p; break;
 case 2: *(__u16 *)res = *(volatile __u16 *)p; break;
 case 4: *(__u32 *)res = *(volatile __u32 *)p; break;



 default:
  __asm__ __volatile__("": : :"memory");
  __builtin_memcpy((void *)res, (const void *)p, size);
  data_access_exceeds_word_size();
  __asm__ __volatile__("": : :"memory");
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void __write_once_size(volatile void *p, void *res, int size)
{
 switch (size) {
 case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
 case 2: *(volatile __u16 *)p = *(__u16 *)res; break;
 case 4: *(volatile __u32 *)p = *(__u32 *)res; break;



 default:
  __asm__ __volatile__("": : :"memory");
  __builtin_memcpy((void *)p, (const void *)res, size);
  data_access_exceeds_word_size();
  __asm__ __volatile__("": : :"memory");
 }
}
# 5 "include/linux/linkage.h" 2

# 1 "include/linux/export.h" 1
# 26 "include/linux/export.h"
struct kernel_symbol
{
 unsigned long value;
 const char *name;
};
# 7 "include/linux/linkage.h" 2
# 1 "./arch/arm/include/asm/linkage.h" 1
# 8 "include/linux/linkage.h" 2
# 10 "include/linux/preempt.h" 2
# 1 "include/linux/list.h" 1



# 1 "include/linux/types.h" 1
# 12 "include/linux/types.h"
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 unsigned short umode_t;
typedef __u32 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;
# 54 "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;
# 130 "include/linux/types.h"
typedef u64 sector_t;
typedef u64 blkcnt_t;
# 146 "include/linux/types.h"
typedef u32 dma_addr_t;


typedef unsigned gfp_t;
typedef unsigned fmode_t;
typedef unsigned oom_flags_t;




typedef u32 phys_addr_t;


typedef phys_addr_t resource_size_t;





typedef unsigned long irq_hw_number_t;

typedef struct {
 int counter;
} atomic_t;







struct list_head {
 struct list_head *next, *prev;
};

struct hlist_head {
 struct hlist_node *first;
};

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

struct ustat {
 __kernel_daddr_t f_tfree;
 __kernel_ino_t f_tinode;
 char f_fname[6];
 char f_fpack[6];
};






struct callback_head {
 struct callback_head *next;
 void (*func)(struct callback_head *head);
};



typedef u64 cycle_t;
# 5 "include/linux/list.h" 2
# 1 "include/linux/stddef.h" 1
# 6 "include/linux/list.h" 2
# 1 "include/linux/poison.h" 1
# 7 "include/linux/list.h" 2
# 1 "./include/uapi/linux/const.h" 1
# 8 "include/linux/list.h" 2
# 1 "include/linux/kernel.h" 1




# 1 "/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 102 "/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 6 "include/linux/kernel.h" 2

# 1 "include/linux/stddef.h" 1
# 8 "include/linux/kernel.h" 2


# 1 "include/linux/bitops.h" 1
# 27 "include/linux/bitops.h"
extern unsigned int __sw_hweight8(unsigned int w);
extern unsigned int __sw_hweight16(unsigned int w);
extern unsigned int __sw_hweight32(unsigned int w);
extern unsigned long __sw_hweight64(__u64 w);





# 1 "./arch/arm/include/asm/bitops.h" 1
# 27 "./arch/arm/include/asm/bitops.h"
# 1 "include/linux/irqflags.h" 1
# 15 "include/linux/irqflags.h"
# 1 "./arch/arm/include/asm/irqflags.h" 1





# 1 "./arch/arm/include/asm/ptrace.h" 1
# 13 "./arch/arm/include/asm/ptrace.h"
# 1 "./arch/arm/include/uapi/asm/ptrace.h" 1
# 13 "./arch/arm/include/uapi/asm/ptrace.h"
# 1 "./arch/arm/include/asm/hwcap.h" 1



# 1 "./arch/arm/include/uapi/asm/hwcap.h" 1
# 5 "./arch/arm/include/asm/hwcap.h" 2
# 13 "./arch/arm/include/asm/hwcap.h"
extern unsigned int elf_hwcap, elf_hwcap2;
# 14 "./arch/arm/include/uapi/asm/ptrace.h" 2
# 14 "./arch/arm/include/asm/ptrace.h" 2


struct pt_regs {
 unsigned long uregs[18];
};
# 50 "./arch/arm/include/asm/ptrace.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int valid_user_regs(struct pt_regs *regs)
{

 unsigned long mode = regs->uregs[16] & 0x0000001f;




 regs->uregs[16] &= ~(0x00000040 | 0x00000100);

 if ((regs->uregs[16] & 0x00000080) == 0) {
  if (mode == 0x00000010)
   return 1;
  if (elf_hwcap & (1 << 3) && mode == 0x00000000)
   return 1;
 }




 regs->uregs[16] &= 0xff000000 | 0x00ff0000 | 0x0000ff00 | 0x00000020 | 0x00000010;
 if (!(elf_hwcap & (1 << 3)))
  regs->uregs[16] |= 0x00000010;

 return 0;



}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long regs_return_value(struct pt_regs *regs)
{
 return regs->uregs[0];
}
# 93 "./arch/arm/include/asm/ptrace.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void instruction_pointer_set(struct pt_regs *regs,
        unsigned long val)
{
 (regs)->uregs[15] = val;
}


extern unsigned long profile_pc(struct pt_regs *regs);
# 119 "./arch/arm/include/asm/ptrace.h"
# 1 "include/linux/stddef.h" 1
# 120 "./arch/arm/include/asm/ptrace.h" 2



extern int regs_query_register_offset(const char *name);
extern const char *regs_query_register_name(unsigned int offset);
extern bool regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr);
extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
            unsigned int n);
# 138 "./arch/arm/include/asm/ptrace.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long regs_get_register(struct pt_regs *regs,
           unsigned int offset)
{
 if (__builtin_expect(!!(offset > (__builtin_offsetof(struct pt_regs,uregs[17]))), 0))
  return 0;
 return *(unsigned long *)((unsigned long)regs + offset);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long kernel_stack_pointer(struct pt_regs *regs)
{
 return regs->uregs[13];
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long user_stack_pointer(struct pt_regs *regs)
{
 return regs->uregs[13];
}
# 7 "./arch/arm/include/asm/irqflags.h" 2
# 23 "./arch/arm/include/asm/irqflags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long arch_local_irq_save(void)
{
 unsigned long flags;

 asm volatile(
  "	mrs	%0, " "cpsr" "	@ arch_local_irq_save\n"
  "	cpsid	i"
  : "=r" (flags) : : "memory", "cc");
 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_local_irq_enable(void)
{
 asm volatile(
  "	cpsie i			@ arch_local_irq_enable"
  :
  :
  : "memory", "cc");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_local_irq_disable(void)
{
 asm volatile(
  "	cpsid i			@ arch_local_irq_disable"
  :
  :
  : "memory", "cc");
}
# 138 "./arch/arm/include/asm/irqflags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long arch_local_save_flags(void)
{
 unsigned long flags;
 asm volatile(
  "	mrs	%0, " "cpsr" "	@ local_save_flags"
  : "=r" (flags) : : "memory", "cc");
 return flags;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_local_irq_restore(unsigned long flags)
{
 asm volatile(
  "	msr	" "cpsr_c" ", %0	@ local_irq_restore"
  :
  : "r" (flags)
  : "memory", "cc");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_irqs_disabled_flags(unsigned long flags)
{
 return flags & 0x00000080;
}
# 16 "include/linux/irqflags.h" 2
# 28 "./arch/arm/include/asm/bitops.h" 2
# 1 "./arch/arm/include/asm/barrier.h" 1




# 1 "./arch/arm/include/asm/outercache.h" 1
# 26 "./arch/arm/include/asm/outercache.h"
struct l2x0_regs;

struct outer_cache_fns {
 void (*inv_range)(unsigned long, unsigned long);
 void (*clean_range)(unsigned long, unsigned long);
 void (*flush_range)(unsigned long, unsigned long);
 void (*flush_all)(void);
 void (*disable)(void);

 void (*sync)(void);

 void (*resume)(void);


 void (*write_sec)(unsigned long, unsigned);
 void (*configure)(const struct l2x0_regs *);
};

extern struct outer_cache_fns outer_cache;







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void outer_inv_range(phys_addr_t start, phys_addr_t end)
{
 if (outer_cache.inv_range)
  outer_cache.inv_range(start, end);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void outer_clean_range(phys_addr_t start, phys_addr_t end)
{
 if (outer_cache.clean_range)
  outer_cache.clean_range(start, end);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void outer_flush_range(phys_addr_t start, phys_addr_t end)
{
 if (outer_cache.flush_range)
  outer_cache.flush_range(start, end);
}
# 91 "./arch/arm/include/asm/outercache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void outer_flush_all(void)
{
 if (outer_cache.flush_all)
  outer_cache.flush_all();
}
# 104 "./arch/arm/include/asm/outercache.h"
extern void outer_disable(void);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void outer_resume(void)
{
 if (outer_cache.resume)
  outer_cache.resume();
}
# 139 "./arch/arm/include/asm/outercache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void outer_sync(void)
{
 if (outer_cache.sync)
  outer_cache.sync();
}
# 6 "./arch/arm/include/asm/barrier.h" 2
# 29 "./arch/arm/include/asm/bitops.h" 2






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ____atomic_set_bit(unsigned int bit, volatile unsigned long *p)
{
 unsigned long flags;
 unsigned long mask = 1UL << (bit & 31);

 p += bit >> 5;

 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0);
 *p |= mask;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ____atomic_clear_bit(unsigned int bit, volatile unsigned long *p)
{
 unsigned long flags;
 unsigned long mask = 1UL << (bit & 31);

 p += bit >> 5;

 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0);
 *p &= ~mask;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ____atomic_change_bit(unsigned int bit, volatile unsigned long *p)
{
 unsigned long flags;
 unsigned long mask = 1UL << (bit & 31);

 p += bit >> 5;

 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0);
 *p ^= mask;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
____atomic_test_and_set_bit(unsigned int bit, volatile unsigned long *p)
{
 unsigned long flags;
 unsigned int res;
 unsigned long mask = 1UL << (bit & 31);

 p += bit >> 5;

 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0);
 res = *p;
 *p = res | mask;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);

 return (res & mask) != 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
____atomic_test_and_clear_bit(unsigned int bit, volatile unsigned long *p)
{
 unsigned long flags;
 unsigned int res;
 unsigned long mask = 1UL << (bit & 31);

 p += bit >> 5;

 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0);
 res = *p;
 *p = res & ~mask;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);

 return (res & mask) != 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
____atomic_test_and_change_bit(unsigned int bit, volatile unsigned long *p)
{
 unsigned long flags;
 unsigned int res;
 unsigned long mask = 1UL << (bit & 31);

 p += bit >> 5;

 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0);
 res = *p;
 *p = res ^ mask;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);

 return (res & mask) != 0;
}

# 1 "include/asm-generic/bitops/non-atomic.h" 1
# 15 "include/asm-generic/bitops/non-atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int test_bit(int nr, const volatile unsigned long *addr)
{
 return 1UL & (addr[((nr) / 32)] >> (nr & (32 -1)));
}
# 123 "./arch/arm/include/asm/bitops.h" 2
# 152 "./arch/arm/include/asm/bitops.h"
extern void _set_bit(int nr, volatile unsigned long * p);
extern void _clear_bit(int nr, volatile unsigned long * p);
extern void _change_bit(int nr, volatile unsigned long * p);
extern int _test_and_set_bit(int nr, volatile unsigned long * p);
extern int _test_and_clear_bit(int nr, volatile unsigned long * p);
extern int _test_and_change_bit(int nr, volatile unsigned long * p);




extern int _find_first_zero_bit_le(const void * p, unsigned size);
extern int _find_next_zero_bit_le(const void * p, int size, int offset);
extern int _find_first_bit_le(const unsigned long *p, unsigned size);
extern int _find_next_bit_le(const unsigned long *p, int size, int offset);




extern int _find_first_zero_bit_be(const void * p, unsigned size);
extern int _find_next_zero_bit_be(const void * p, int size, int offset);
extern int _find_first_bit_be(const unsigned long *p, unsigned size);
extern int _find_next_bit_be(const unsigned long *p, int size, int offset);
# 225 "./arch/arm/include/asm/bitops.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int constant_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;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int __clz(unsigned int x)
{
 unsigned int ret;

 asm("clz\t%0, %1" : "=r" (ret) : "r" (x));

 return ret;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int fls(int x)
{
 if (__builtin_constant_p(x))
        return constant_fls(x);

 return 32 - __clz(x);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __fls(unsigned long x)
{
 return fls(x) - 1;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ffs(int x)
{
 return fls(x & -x);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __ffs(unsigned long x)
{
 return ffs(x) - 1;
}





# 1 "include/asm-generic/bitops/fls64.h" 1
# 18 "include/asm-generic/bitops/fls64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) int fls64(__u64 x)
{
 __u32 h = x >> 32;
 if (h)
  return fls(h) + 32;
 return fls(x);
}
# 313 "./arch/arm/include/asm/bitops.h" 2

# 1 "include/asm-generic/bitops/sched.h" 1
# 12 "include/asm-generic/bitops/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;



}
# 315 "./arch/arm/include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/hweight.h" 1



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





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int __arch_hweight32(unsigned int w)
{
 return __sw_hweight32(w);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int __arch_hweight16(unsigned int w)
{
 return __sw_hweight16(w);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int __arch_hweight8(unsigned int w)
{
 return __sw_hweight8(w);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __arch_hweight64(__u64 w)
{
 return __sw_hweight64(w);
}
# 5 "include/asm-generic/bitops/hweight.h" 2
# 1 "include/asm-generic/bitops/const_hweight.h" 1
# 6 "include/asm-generic/bitops/hweight.h" 2
# 316 "./arch/arm/include/asm/bitops.h" 2
# 1 "include/asm-generic/bitops/lock.h" 1
# 317 "./arch/arm/include/asm/bitops.h" 2
# 340 "./arch/arm/include/asm/bitops.h"
# 1 "include/asm-generic/bitops/le.h" 1




# 1 "./arch/arm/include/uapi/asm/byteorder.h" 1
# 21 "./arch/arm/include/uapi/asm/byteorder.h"
# 1 "include/linux/byteorder/little_endian.h" 1



# 1 "include/uapi/linux/byteorder/little_endian.h" 1
# 12 "include/uapi/linux/byteorder/little_endian.h"
# 1 "include/linux/swab.h" 1



# 1 "include/uapi/linux/swab.h" 1





# 1 "./arch/arm/include/asm/swab.h" 1
# 18 "./arch/arm/include/asm/swab.h"
# 1 "./arch/arm/include/uapi/asm/swab.h" 1
# 19 "./arch/arm/include/asm/swab.h" 2



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __arch_swahb32(__u32 x)
{
 __asm__ ("rev16 %0, %1" : "=r" (x) : "r" (x));
 return x;
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __arch_swab32(__u32 x)
{
 __asm__ ("rev %0, %1" : "=r" (x) : "r" (x));
 return x;
}
# 7 "include/uapi/linux/swab.h" 2
# 46 "include/uapi/linux/swab.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u16 __fswab16(__u16 val)
{



 return ((__u16)__arch_swahb32(val));



}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __fswab32(__u32 val)
{

 return __builtin_bswap32(val);





}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u64 __fswab64(__u64 val)
{

 return __builtin_bswap64(val);
# 81 "include/uapi/linux/swab.h"
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __fswahw32(__u32 val)
{



 return ((__u32)( (((__u32)(val) & (__u32)0x0000ffffUL) << 16) | (((__u32)(val) & (__u32)0xffff0000UL) >> 16)));

}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __fswahb32(__u32 val)
{

 return __arch_swahb32(val);



}
# 154 "include/uapi/linux/swab.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __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)) __attribute__((no_instrument_function)) __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)) __attribute__((no_instrument_function)) __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)) __attribute__((no_instrument_function)) __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)) __attribute__((no_instrument_function)) __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)) __attribute__((no_instrument_function)) void __swab16s(__u16 *p)
{



 *p = __swab16p(p);

}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __swab32s(__u32 *p)
{



 *p = __swab32p(p);

}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __swab64s(__u64 *p)
{



 *p = __swab64p(p);

}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __swahw32s(__u32 *p)
{



 *p = __swahw32p(p);

}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __swahb32s(__u32 *p)
{



 *p = __swahb32p(p);

}
# 5 "include/linux/swab.h" 2
# 13 "include/uapi/linux/byteorder/little_endian.h" 2
# 43 "include/uapi/linux/byteorder/little_endian.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __le64 __cpu_to_le64p(const __u64 *p)
{
 return ( __le64)*p;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u64 __le64_to_cpup(const __le64 *p)
{
 return ( __u64)*p;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __le32 __cpu_to_le32p(const __u32 *p)
{
 return ( __le32)*p;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u32 __le32_to_cpup(const __le32 *p)
{
 return ( __u32)*p;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __le16 __cpu_to_le16p(const __u16 *p)
{
 return ( __le16)*p;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u16 __le16_to_cpup(const __le16 *p)
{
 return ( __u16)*p;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __be64 __cpu_to_be64p(const __u64 *p)
{
 return ( __be64)__swab64p(p);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u64 __be64_to_cpup(const __be64 *p)
{
 return __swab64p((__u64 *)p);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __be32 __cpu_to_be32p(const __u32 *p)
{
 return ( __be32)__swab32p(p);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u32 __be32_to_cpup(const __be32 *p)
{
 return __swab32p((__u32 *)p);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __be16 __cpu_to_be16p(const __u16 *p)
{
 return ( __be16)__swab16p(p);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u16 __be16_to_cpup(const __be16 *p)
{
 return __swab16p((__u16 *)p);
}
# 5 "include/linux/byteorder/little_endian.h" 2

# 1 "include/linux/byteorder/generic.h" 1
# 143 "include/linux/byteorder/generic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void le16_add_cpu(__le16 *var, u16 val)
{
 *var = (( __le16)(__u16)((( __u16)(__le16)(*var)) + val));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void le32_add_cpu(__le32 *var, u32 val)
{
 *var = (( __le32)(__u32)((( __u32)(__le32)(*var)) + val));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void le64_add_cpu(__le64 *var, u64 val)
{
 *var = (( __le64)(__u64)((( __u64)(__le64)(*var)) + val));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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))));
}
# 7 "include/linux/byteorder/little_endian.h" 2
# 22 "./arch/arm/include/uapi/asm/byteorder.h" 2
# 6 "include/asm-generic/bitops/le.h" 2





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long find_next_zero_bit_le(const void *addr,
  unsigned long size, unsigned long offset)
{
 return _find_next_zero_bit_le(addr,size,offset);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long find_next_bit_le(const void *addr,
  unsigned long size, unsigned long offset)
{
 return _find_next_bit_le(addr,size,offset);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long find_first_zero_bit_le(const void *addr,
  unsigned long size)
{
 return _find_first_zero_bit_le(addr,size);
}
# 52 "include/asm-generic/bitops/le.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int test_bit_le(int nr, const void *addr)
{
 return test_bit(nr ^ 0, addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_bit_le(int nr, void *addr)
{
 _set_bit(nr ^ 0,addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void clear_bit_le(int nr, void *addr)
{
 _clear_bit(nr ^ 0,addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __set_bit_le(int nr, void *addr)
{
 __set_bit(nr ^ 0, addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __clear_bit_le(int nr, void *addr)
{
 __clear_bit(nr ^ 0, addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int test_and_set_bit_le(int nr, void *addr)
{
 return _test_and_set_bit(nr ^ 0,addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int test_and_clear_bit_le(int nr, void *addr)
{
 return _test_and_clear_bit(nr ^ 0,addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __test_and_set_bit_le(int nr, void *addr)
{
 return __test_and_set_bit(nr ^ 0, addr);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __test_and_clear_bit_le(int nr, void *addr)
{
 return __test_and_clear_bit(nr ^ 0, addr);
}
# 341 "./arch/arm/include/asm/bitops.h" 2




# 1 "include/asm-generic/bitops/ext2-atomic-setbit.h" 1
# 346 "./arch/arm/include/asm/bitops.h" 2
# 37 "include/linux/bitops.h" 2
# 60 "include/linux/bitops.h"
static __inline__ __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_bitmask_order(unsigned int count)
{
 int order;

 order = fls(count);
 return order;
}

static __inline__ __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) unsigned long hweight_long(unsigned long w)
{
 return sizeof(w) == 4 ? (__builtin_constant_p(w) ? ((((unsigned int) ((!!((w) & (1ULL << 0))) + (!!((w) & (1ULL << 1))) + (!!((w) & (1ULL << 2))) + (!!((w) & (1ULL << 3))) + (!!((w) & (1ULL << 4))) + (!!((w) & (1ULL << 5))) + (!!((w) & (1ULL << 6))) + (!!((w) & (1ULL << 7))))) + ((unsigned int) ((!!(((w) >> 8) & (1ULL << 0))) + (!!(((w) >> 8) & (1ULL << 1))) + (!!(((w) >> 8) & (1ULL << 2))) + (!!(((w) >> 8) & (1ULL << 3))) + (!!(((w) >> 8) & (1ULL << 4))) + (!!(((w) >> 8) & (1ULL << 5))) + (!!(((w) >> 8) & (1ULL << 6))) + (!!(((w) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!(((w) >> 16) & (1ULL << 0))) + (!!(((w) >> 16) & (1ULL << 1))) + (!!(((w) >> 16) & (1ULL << 2))) + (!!(((w) >> 16) & (1ULL << 3))) + (!!(((w) >> 16) & (1ULL << 4))) + (!!(((w) >> 16) & (1ULL << 5))) + (!!(((w) >> 16) & (1ULL << 6))) + (!!(((w) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!((((w) >> 16) >> 8) & (1ULL << 0))) + (!!((((w) >> 16) >> 8) & (1ULL << 1))) + (!!((((w) >> 16) >> 8) & (1ULL << 2))) + (!!((((w) >> 16) >> 8) & (1ULL << 3))) + (!!((((w) >> 16) >> 8) & (1ULL << 4))) + (!!((((w) >> 16) >> 8) & (1ULL << 5))) + (!!((((w) >> 16) >> 8) & (1ULL << 6))) + (!!((((w) >> 16) >> 8) & (1ULL << 7))))))) : __arch_hweight32(w)) : (__builtin_constant_p(w) ? (((((unsigned int) ((!!((w) & (1ULL << 0))) + (!!((w) & (1ULL << 1))) + (!!((w) & (1ULL << 2))) + (!!((w) & (1ULL << 3))) + (!!((w) & (1ULL << 4))) + (!!((w) & (1ULL << 5))) + (!!((w) & (1ULL << 6))) + (!!((w) & (1ULL << 7))))) + ((unsigned int) ((!!(((w) >> 8) & (1ULL << 0))) + (!!(((w) >> 8) & (1ULL << 1))) + (!!(((w) >> 8) & (1ULL << 2))) + (!!(((w) >> 8) & (1ULL << 3))) + (!!(((w) >> 8) & (1ULL << 4))) + (!!(((w) >> 8) & (1ULL << 5))) + (!!(((w) >> 8) & (1ULL << 6))) + (!!(((w) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!(((w) >> 16) & (1ULL << 0))) + (!!(((w) >> 16) & (1ULL << 1))) + (!!(((w) >> 16) & (1ULL << 2))) + (!!(((w) >> 16) & (1ULL << 3))) + (!!(((w) >> 16) & (1ULL << 4))) + (!!(((w) >> 16) & (1ULL << 5))) + (!!(((w) >> 16) & (1ULL << 6))) + (!!(((w) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!((((w) >> 16) >> 8) & (1ULL << 0))) + (!!((((w) >> 16) >> 8) & (1ULL << 1))) + (!!((((w) >> 16) >> 8) & (1ULL << 2))) + (!!((((w) >> 16) >> 8) & (1ULL << 3))) + (!!((((w) >> 16) >> 8) & (1ULL << 4))) + (!!((((w) >> 16) >> 8) & (1ULL << 5))) + (!!((((w) >> 16) >> 8) & (1ULL << 6))) + (!!((((w) >> 16) >> 8) & (1ULL << 7))))))) + ((((unsigned int) ((!!(((w) >> 32) & (1ULL << 0))) + (!!(((w) >> 32) & (1ULL << 1))) + (!!(((w) >> 32) & (1ULL << 2))) + (!!(((w) >> 32) & (1ULL << 3))) + (!!(((w) >> 32) & (1ULL << 4))) + (!!(((w) >> 32) & (1ULL << 5))) + (!!(((w) >> 32) & (1ULL << 6))) + (!!(((w) >> 32) & (1ULL << 7))))) + ((unsigned int) ((!!((((w) >> 32) >> 8) & (1ULL << 0))) + (!!((((w) >> 32) >> 8) & (1ULL << 1))) + (!!((((w) >> 32) >> 8) & (1ULL << 2))) + (!!((((w) >> 32) >> 8) & (1ULL << 3))) + (!!((((w) >> 32) >> 8) & (1ULL << 4))) + (!!((((w) >> 32) >> 8) & (1ULL << 5))) + (!!((((w) >> 32) >> 8) & (1ULL << 6))) + (!!((((w) >> 32) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!((((w) >> 32) >> 16) & (1ULL << 0))) + (!!((((w) >> 32) >> 16) & (1ULL << 1))) + (!!((((w) >> 32) >> 16) & (1ULL << 2))) + (!!((((w) >> 32) >> 16) & (1ULL << 3))) + (!!((((w) >> 32) >> 16) & (1ULL << 4))) + (!!((((w) >> 32) >> 16) & (1ULL << 5))) + (!!((((w) >> 32) >> 16) & (1ULL << 6))) + (!!((((w) >> 32) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 0))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 1))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 2))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 3))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 4))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 5))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 6))) + (!!(((((w) >> 32) >> 16) >> 8) & (1ULL << 7)))))))) : __arch_hweight64(w));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u64 rol64(__u64 word, unsigned int shift)
{
 return (word << shift) | (word >> (64 - shift));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u64 ror64(__u64 word, unsigned int shift)
{
 return (word >> shift) | (word << (64 - shift));
}






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






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






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u16 rol16(__u16 word, unsigned int shift)
{
 return (word << shift) | (word >> (16 - shift));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u16 ror16(__u16 word, unsigned int shift)
{
 return (word >> shift) | (word << (16 - shift));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u8 rol8(__u8 word, unsigned int shift)
{
 return (word << shift) | (word >> (8 - shift));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __u8 ror8(__u8 word, unsigned int shift)
{
 return (word >> shift) | (word << (8 - shift));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __s32 sign_extend32(__u32 value, int index)
{
 __u8 shift = 31 - index;
 return (__s32)(value << shift) >> shift;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned fls_long(unsigned long l)
{
 if (sizeof(l) == 4)
  return fls(l);
 return fls64(l);
}
# 189 "include/linux/bitops.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __ffs64(u64 word)
{

 if (((u32)word) == 0UL)
  return __ffs((u32)(word >> 32)) + 32;



 return __ffs((unsigned long)word);
}
# 225 "include/linux/bitops.h"
extern unsigned long find_last_bit(const unsigned long *addr,
       unsigned long size);
# 11 "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__((no_instrument_function)) __attribute__((const))
int __ilog2_u32(u32 n)
{
 return fls(n) - 1;
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((const))
int __ilog2_u64(u64 n)
{
 return fls64(n) - 1;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((const))
bool is_power_of_2(unsigned long n)
{
 return (n != 0 && ((n & (n - 1)) == 0));
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((const))
unsigned long __roundup_pow_of_two(unsigned long n)
{
 return 1UL << fls_long(n - 1);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((const))
unsigned long __rounddown_pow_of_two(unsigned long n)
{
 return 1UL << (fls_long(n) - 1);
}
# 12 "include/linux/kernel.h" 2

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




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

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


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);
void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) load_default_modules(void);
int __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) init_rootfs(void);

extern void (*late_time_init)(void);

extern bool initcall_debug;
# 243 "include/linux/init.h"
struct obs_kernel_param {
 const char *str;
 int (*setup_func)(char *);
 int early;
};
# 292 "include/linux/init.h"
void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) parse_early_param(void);
void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) parse_early_options(char *cmdline);
# 6 "include/linux/printk.h" 2
# 1 "include/linux/kern_levels.h" 1
# 7 "include/linux/printk.h" 2

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



# 1 "include/uapi/linux/kernel.h" 1



# 1 "./include/uapi/linux/sysinfo.h" 1






struct sysinfo {
 __kernel_long_t uptime;
 __kernel_ulong_t loads[3];
 __kernel_ulong_t totalram;
 __kernel_ulong_t freeram;
 __kernel_ulong_t sharedram;
 __kernel_ulong_t bufferram;
 __kernel_ulong_t totalswap;
 __kernel_ulong_t freeswap;
 __u16 procs;
 __u16 pad;
 __kernel_ulong_t totalhigh;
 __kernel_ulong_t freehigh;
 __u32 mem_unit;
 char _f[20-2*sizeof(__kernel_ulong_t)-sizeof(__u32)];
};
# 5 "include/uapi/linux/kernel.h" 2
# 5 "include/linux/cache.h" 2
# 1 "./arch/arm/include/asm/cache.h" 1
# 6 "include/linux/cache.h" 2
# 9 "include/linux/printk.h" 2

extern const char linux_banner[];
extern const char linux_proc_banner[];

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int printk_get_level(const char *buffer)
{
 if (buffer[0] == '\001' && buffer[1]) {
  switch (buffer[1]) {
  case '0' ... '7':
  case 'd':
   return buffer[1];
  }
 }
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) const char *printk_skip_level(const char *buffer)
{
 if (printk_get_level(buffer))
  return buffer + 2;

 return buffer;
}
# 44 "include/linux/printk.h"
extern int console_printk[];






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

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

struct va_format {
 const char *fmt;
 va_list *va;
};
# 109 "include/linux/printk.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((format(printf, 1, 2)))
int no_printk(const char *fmt, ...)
{
 return 0;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((format(printf, 1, 2))) __attribute__((__cold__))
void early_printk(const char *s, ...) { }


typedef int(*printk_func_t)(const char *fmt, va_list args);


 __attribute__((format(printf, 5, 0)))
int vprintk_emit(int facility, int level,
   const char *dict, size_t dictlen,
   const char *fmt, va_list args);

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

 __attribute__((format(printf, 5, 6))) __attribute__((__cold__))
int printk_emit(int facility, int level,
  const char *dict, size_t dictlen,
  const char *fmt, ...);

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




__attribute__((format(printf, 1, 2))) __attribute__((__cold__)) int printk_deferred(const char *fmt, ...);






extern int __printk_ratelimit(const char *func);

extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
       unsigned int interval_msec);

extern int printk_delay_msec;
extern int dmesg_restrict;
extern int kptr_restrict;

extern void wake_up_klogd(void);

char *log_buf_addr_get(void);
u32 log_buf_len_get(void);
void log_buf_kexec_setup(void);
void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) setup_log_buf(int early);
void dump_stack_set_arch_desc(const char *fmt, ...);
void dump_stack_print_info(const char *log_lvl);
void show_regs_print_info(const char *log_lvl);
# 231 "include/linux/printk.h"
extern void dump_stack(void) __attribute__((__cold__));
# 275 "include/linux/printk.h"
# 1 "include/linux/dynamic_debug.h" 1
# 9 "include/linux/dynamic_debug.h"
struct _ddebug {




 const char *modname;
 const char *function;
 const char *filename;
 const char *format;
 unsigned int lineno:18;
# 35 "include/linux/dynamic_debug.h"
 unsigned int flags:8;
} __attribute__((aligned(8)));


int ddebug_add_module(struct _ddebug *tab, unsigned int n,
    const char *modname);
# 111 "include/linux/dynamic_debug.h"
# 1 "include/linux/string.h" 1






# 1 "include/linux/stddef.h" 1
# 8 "include/linux/string.h" 2

# 1 "include/uapi/linux/string.h" 1
# 10 "include/linux/string.h" 2

extern char *strndup_user(const char *, long);
extern void *memdup_user(const void *, size_t);




# 1 "./arch/arm/include/asm/string.h" 1
# 10 "./arch/arm/include/asm/string.h"
extern char * strrchr(const char * s, int c);


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


extern void * memcpy(void *, const void *, __kernel_size_t);


extern void * memmove(void *, const void *, __kernel_size_t);


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


extern void * memset(void *, int, __kernel_size_t);

extern void __memzero(void *ptr, __kernel_size_t n);
# 18 "include/linux/string.h" 2


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


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


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


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


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


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


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


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


extern int strcasecmp(const char *s1, const char *s2);


extern int strncasecmp(const char *s1, const char *s2, size_t n);





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


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




extern char * __attribute__((warn_unused_result)) skip_spaces(const char *);

extern char *strim(char *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((warn_unused_result)) char *strstrip(char *str)
{
 return strim(str);
}


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


extern char * strnstr(const char *, const char *, size_t);


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 *);
# 105 "include/linux/string.h"
extern void * memscan(void *,int,__kernel_size_t);


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




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

extern void kfree_const(const void *x);

extern char *kstrdup(const char *s, gfp_t gfp);
extern const char *kstrdup_const(const char *s, gfp_t gfp);
extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
extern char *kstrimdup(const char *s, 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);
extern int strtobool(const char *s, bool *res);







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)) __attribute__((no_instrument_function)) bool strstarts(const char *str, const char *prefix)
{
 return strncmp(str, prefix, strlen(prefix)) == 0;
}

size_t memweight(const void *ptr, size_t bytes);
void memzero_explicit(void *s, size_t count);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) const char *kbasename(const char *path)
{
 const char *tail = strrchr(path, '/');
 return tail ? tail + 1 : path;
}
# 112 "include/linux/dynamic_debug.h" 2


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ddebug_remove_module(const char *mod)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ddebug_dyndbg_module_param_cb(char *param, char *val,
      const char *modname)
{
 if (strstr(param, "dyndbg")) {

  printk("\001" "4" "dyndbg param is supported only in "
   "CONFIG_DYNAMIC_DEBUG builds\n");
  return 0;
 }
 return -22;
}
# 276 "include/linux/printk.h" 2
# 418 "include/linux/printk.h"
extern const struct file_operations kmsg_fops;

enum {
 DUMP_PREFIX_NONE,
 DUMP_PREFIX_ADDRESS,
 DUMP_PREFIX_OFFSET
};
extern int 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);
# 14 "include/linux/kernel.h" 2
# 136 "include/linux/kernel.h"
# 1 "./arch/arm/include/asm/div64.h" 1




# 1 "./arch/arm/include/asm/compiler.h" 1
# 6 "./arch/arm/include/asm/div64.h" 2
# 63 "./arch/arm/include/asm/div64.h"
# 1 "./arch/arm/include/asm/bug.h" 1





# 1 "./arch/arm/include/asm/opcodes.h" 1
# 14 "./arch/arm/include/asm/opcodes.h"
extern unsigned int arm_check_condition(u32 opcode, u32 psr);
# 7 "./arch/arm/include/asm/bug.h" 2
# 61 "./arch/arm/include/asm/bug.h"
# 1 "include/asm-generic/bug.h" 1
# 13 "include/asm-generic/bug.h"
# 1 "include/linux/kernel.h" 1
# 14 "include/asm-generic/bug.h" 2




struct bug_entry {

 unsigned long bug_addr;





 const char *file;



 unsigned short line;

 unsigned short flags;
};
# 65 "include/asm-generic/bug.h"
extern __attribute__((format(printf, 3, 4)))
void warn_slowpath_fmt(const char *file, const int line,
         const char *fmt, ...);
extern __attribute__((format(printf, 4, 5)))
void warn_slowpath_fmt_taint(const char *file, const int line, unsigned taint,
        const char *fmt, ...);
extern void warn_slowpath_null(const char *file, const int line);
# 62 "./arch/arm/include/asm/bug.h" 2

struct pt_regs;
void die(const char *msg, struct pt_regs *regs, int err);

struct siginfo;
void arm_notify_die(const char *str, struct pt_regs *regs, struct siginfo *info,
  unsigned long err, unsigned long trap);
# 78 "./arch/arm/include/asm/bug.h"
void hook_fault_code(int nr, int (*fn)(unsigned long, unsigned int,
           struct pt_regs *),
       int sig, int code, const char *name);

void hook_ifault_code(int nr, int (*fn)(unsigned long, unsigned int,
           struct pt_regs *),
       int sig, int code, const char *name);

extern void c_backtrace(unsigned long fp, int pmode);

struct mm_struct;
extern void show_pte(struct mm_struct *mm, unsigned long addr);
extern void __show_regs(struct pt_regs *);
# 64 "./arch/arm/include/asm/div64.h" 2
# 137 "include/linux/kernel.h" 2
# 165 "include/linux/kernel.h"
struct completion;
struct pt_regs;
struct user;
# 193 "include/linux/kernel.h"
  static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ___might_sleep(const char *file, int line,
       int preempt_offset) { }
  static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __might_sleep(const char *file, int line,
       int preempt_offset) { }
# 240 "include/linux/kernel.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u32 reciprocal_scale(u32 val, u32 ep_ro)
{
 return (u32)(((u64) val * ep_ro) >> 32);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void might_fault(void) { }


extern struct atomic_notifier_head panic_notifier_list;
extern long (*panic_blink)(int state);
__attribute__((format(printf, 1, 2)))
void panic(const char *fmt, ...)
 __attribute__((noreturn)) __attribute__((__cold__));
extern void oops_enter(void);
extern void oops_exit(void);
void print_oops_end_marker(void);
extern int oops_may_print(void);
void do_exit(long error_code)
 __attribute__((noreturn));
void complete_and_exit(struct completion *, long)
 __attribute__((noreturn));


int __attribute__((warn_unused_result)) _kstrtoul(const char *s, unsigned int base, unsigned long *res);
int __attribute__((warn_unused_result)) _kstrtol(const char *s, unsigned int base, long *res);

int __attribute__((warn_unused_result)) kstrtoull(const char *s, unsigned int base, unsigned long long *res);
int __attribute__((warn_unused_result)) kstrtoll(const char *s, unsigned int base, long long *res);
# 289 "include/linux/kernel.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtoul(const char *s, unsigned int base, unsigned long *res)
{




 if (sizeof(unsigned long) == sizeof(unsigned long long) &&
     __alignof__(unsigned long) == __alignof__(unsigned long long))
  return kstrtoull(s, base, (unsigned long long *)res);
 else
  return _kstrtoul(s, base, res);
}
# 318 "include/linux/kernel.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtol(const char *s, unsigned int base, long *res)
{




 if (sizeof(long) == sizeof(long long) &&
     __alignof__(long) == __alignof__(long long))
  return kstrtoll(s, base, (long long *)res);
 else
  return _kstrtol(s, base, res);
}

int __attribute__((warn_unused_result)) kstrtouint(const char *s, unsigned int base, unsigned int *res);
int __attribute__((warn_unused_result)) kstrtoint(const char *s, unsigned int base, int *res);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtou64(const char *s, unsigned int base, u64 *res)
{
 return kstrtoull(s, base, res);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtos64(const char *s, unsigned int base, s64 *res)
{
 return kstrtoll(s, base, res);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtou32(const char *s, unsigned int base, u32 *res)
{
 return kstrtouint(s, base, res);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtos32(const char *s, unsigned int base, s32 *res)
{
 return kstrtoint(s, base, res);
}

int __attribute__((warn_unused_result)) kstrtou16(const char *s, unsigned int base, u16 *res);
int __attribute__((warn_unused_result)) kstrtos16(const char *s, unsigned int base, s16 *res);
int __attribute__((warn_unused_result)) kstrtou8(const char *s, unsigned int base, u8 *res);
int __attribute__((warn_unused_result)) kstrtos8(const char *s, unsigned int base, s8 *res);

int __attribute__((warn_unused_result)) kstrtoull_from_user(const char *s, size_t count, unsigned int base, unsigned long long *res);
int __attribute__((warn_unused_result)) kstrtoll_from_user(const char *s, size_t count, unsigned int base, long long *res);
int __attribute__((warn_unused_result)) kstrtoul_from_user(const char *s, size_t count, unsigned int base, unsigned long *res);
int __attribute__((warn_unused_result)) kstrtol_from_user(const char *s, size_t count, unsigned int base, long *res);
int __attribute__((warn_unused_result)) kstrtouint_from_user(const char *s, size_t count, unsigned int base, unsigned int *res);
int __attribute__((warn_unused_result)) kstrtoint_from_user(const char *s, size_t count, unsigned int base, int *res);
int __attribute__((warn_unused_result)) kstrtou16_from_user(const char *s, size_t count, unsigned int base, u16 *res);
int __attribute__((warn_unused_result)) kstrtos16_from_user(const char *s, size_t count, unsigned int base, s16 *res);
int __attribute__((warn_unused_result)) kstrtou8_from_user(const char *s, size_t count, unsigned int base, u8 *res);
int __attribute__((warn_unused_result)) kstrtos8_from_user(const char *s, size_t count, unsigned int base, s8 *res);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtou64_from_user(const char *s, size_t count, unsigned int base, u64 *res)
{
 return kstrtoull_from_user(s, count, base, res);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtos64_from_user(const char *s, size_t count, unsigned int base, s64 *res)
{
 return kstrtoll_from_user(s, count, base, res);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtou32_from_user(const char *s, size_t count, unsigned int base, u32 *res)
{
 return kstrtouint_from_user(s, count, base, res);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kstrtos32_from_user(const char *s, size_t count, unsigned int base, s32 *res)
{
 return kstrtoint_from_user(s, count, base, res);
}



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 num_to_str(char *buf, int size, unsigned long long num);



extern __attribute__((format(printf, 2, 3))) int sprintf(char *buf, const char * fmt, ...);
extern __attribute__((format(printf, 2, 0))) int vsprintf(char *buf, const char *, va_list);
extern __attribute__((format(printf, 3, 4)))
int snprintf(char *buf, size_t size, const char *fmt, ...);
extern __attribute__((format(printf, 3, 0)))
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
extern __attribute__((format(printf, 3, 4)))
int scnprintf(char *buf, size_t size, const char *fmt, ...);
extern __attribute__((format(printf, 3, 0)))
int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
extern __attribute__((format(printf, 2, 3)))
char *kasprintf(gfp_t gfp, const char *fmt, ...);
extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);

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

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

extern int core_kernel_text(unsigned long addr);
extern int core_kernel_data(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);

unsigned long int_sqrt(unsigned long);

extern void bust_spinlocks(int yes);
extern int oops_in_progress;
extern int panic_timeout;
extern int panic_on_oops;
extern int panic_on_unrecovered_nmi;
extern int panic_on_io_nmi;
extern int panic_on_warn;
extern int sysctl_panic_on_stackoverflow;




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_arch_panic_timeout(int timeout, int arch_default_timeout)
{
 if (panic_timeout == arch_default_timeout)
  panic_timeout = timeout;
}
extern const char *print_tainted(void);
enum lockdep_ok {
 LOCKDEP_STILL_OK,
 LOCKDEP_NOW_UNRELIABLE
};
extern void add_taint(unsigned flag, enum lockdep_ok);
extern int test_taint(unsigned flag);
extern unsigned long get_taint(void);
extern int root_mountflags;

extern bool early_boot_irqs_disabled;


extern enum system_states {
 SYSTEM_BOOTING,
 SYSTEM_RUNNING,
 SYSTEM_HALT,
 SYSTEM_POWER_OFF,
 SYSTEM_RESTART,
} system_state;
# 488 "include/linux/kernel.h"
extern const char hex_asc[];



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) char *hex_byte_pack(char *buf, u8 byte)
{
 *buf++ = hex_asc[((byte) & 0xf0) >> 4];
 *buf++ = hex_asc[((byte) & 0x0f)];
 return buf;
}

extern const char hex_asc_upper[];



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) char *hex_byte_pack_upper(char *buf, u8 byte)
{
 *buf++ = hex_asc_upper[((byte) & 0xf0) >> 4];
 *buf++ = hex_asc_upper[((byte) & 0x0f)];
 return buf;
}

extern int hex_to_bin(char ch);
extern int __attribute__((warn_unused_result)) hex2bin(u8 *dst, const char *src, size_t count);
extern char *bin2hex(char *dst, const void *src, size_t count);

bool mac_pton(const char *s, u8 *mac);
# 539 "include/linux/kernel.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_off_permanent(void) { }


enum ftrace_dump_mode {
 DUMP_NONE,
 DUMP_ALL,
 DUMP_ORIG,
};
# 692 "include/linux/kernel.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_start(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_stop(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void trace_dump_stack(int skip) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_on(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_off(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int tracing_is_on(void) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_snapshot(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tracing_snapshot_alloc(void) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((format(printf, 1, 2)))
int trace_printk(const char *fmt, ...)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
ftrace_vprintk(const char *fmt, va_list ap)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
# 9 "include/linux/list.h" 2
# 25 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void INIT_LIST_HEAD(struct list_head *list)
{
 list->next = list;
 list->prev = list;
}
# 38 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}
# 61 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_add(struct list_head *new, struct list_head *head)
{
 __list_add(new, head, head->next);
}
# 75 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_add_tail(struct list_head *new, struct list_head *head)
{
 __list_add(new, head->prev, head);
}
# 87 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __list_del(struct list_head * prev, struct list_head * next)
{
 next->prev = prev;
 prev->next = next;
}
# 100 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __list_del_entry(struct list_head *entry)
{
 __list_del(entry->prev, entry->next);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_del(struct list_head *entry)
{
 __list_del(entry->prev, entry->next);
 entry->next = ((void *) 0x00100100 + 0);
 entry->prev = ((void *) 0x00200200 + 0);
}
# 123 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void list_del_init(struct list_head *entry)
{
 __list_del_entry(entry);
 INIT_LIST_HEAD(entry);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_move(struct list_head *list, struct list_head *head)
{
 __list_del_entry(list);
 list_add(list, head);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_move_tail(struct list_head *list,
      struct list_head *head)
{
 __list_del_entry(list);
 list_add_tail(list, head);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int list_is_last(const struct list_head *list,
    const struct list_head *head)
{
 return list->next == head;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int list_empty(const struct list_head *head)
{
 return head->next == head;
}
# 205 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void list_rotate_left(struct list_head *head)
{
 struct list_head *first;

 if (!list_empty(head)) {
  first = head->next;
  list_move_tail(first, head);
 }
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int list_is_singular(const struct list_head *head)
{
 return !list_empty(head) && (head->next == head->prev);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}
# 260 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void list_splice_tail(struct list_head *list,
    struct list_head *head)
{
 if (!list_empty(list))
  __list_splice(list, head->prev, head);
}
# 319 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
 }
}
# 336 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
 }
}
# 598 "include/linux/list.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void INIT_HLIST_NODE(struct hlist_node *h)
{
 h->next = ((void *)0);
 h->pprev = ((void *)0);
}

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

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void hlist_del(struct hlist_node *n)
{
 __hlist_del(n);
 n->next = ((void *) 0x00100100 + 0);
 n->pprev = ((void *) 0x00200200 + 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_del_init(struct hlist_node *n)
{
 if (!hlist_unhashed(n)) {
  __hlist_del(n);
  INIT_HLIST_NODE(n);
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void hlist_add_behind(struct hlist_node *n,
        struct hlist_node *prev)
{
 n->next = prev->next;
 prev->next = n;
 n->pprev = &prev->next;

 if (n->next)
  n->next->pprev = &n->next;
}


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





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
}
# 11 "include/linux/preempt.h" 2







# 1 "arch/arm/include/generated/asm/preempt.h" 1
# 1 "include/asm-generic/preempt.h" 1



# 1 "include/linux/thread_info.h" 1
# 11 "include/linux/thread_info.h"
# 1 "include/linux/bug.h" 1






enum bug_trap_type {
 BUG_TRAP_TYPE_NONE = 0,
 BUG_TRAP_TYPE_WARN = 1,
 BUG_TRAP_TYPE_BUG = 2,
};

struct pt_regs;
# 91 "include/linux/bug.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_warning_bug(const struct bug_entry *bug)
{
 return bug->flags & (1 << 0);
}

const struct bug_entry *find_bug(unsigned long bugaddr);

enum bug_trap_type report_bug(unsigned long bug_addr, struct pt_regs *regs);


int is_valid_bugaddr(unsigned long addr);
# 12 "include/linux/thread_info.h" 2

struct timespec;
struct compat_timespec;




struct restart_block {
 long (*fn)(struct restart_block *);
 union {

  struct {
   u32 *uaddr;
   u32 val;
   u32 flags;
   u32 bitset;
   u64 time;
   u32 *uaddr2;
  } futex;

  struct {
   clockid_t clockid;
   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 "./arch/arm/include/asm/thread_info.h" 1
# 16 "./arch/arm/include/asm/thread_info.h"
# 1 "./arch/arm/include/asm/fpstate.h" 1
# 26 "./arch/arm/include/asm/fpstate.h"
struct vfp_hard_struct {

 __u64 fpregs[32];






 __u32 fpexc;
 __u32 fpscr;



 __u32 fpinst;
 __u32 fpinst2;


 __u32 cpu;

};

union vfp_state {
 struct vfp_hard_struct hard;
};

extern void vfp_flush_thread(union vfp_state *);
extern void vfp_release_thread(union vfp_state *);



struct fp_hard_struct {
 unsigned int save[35];
};



struct fp_soft_struct {
 unsigned int save[35];
};



struct iwmmxt_struct {
 unsigned int save[0x98 / sizeof(unsigned int)];
};

union fp_state {
 struct fp_hard_struct hard;
 struct fp_soft_struct soft;



};



struct crunch_state {
 unsigned int mvdx[16][2];
 unsigned int mvax[4][3];
 unsigned int dspsc[2];
};
# 17 "./arch/arm/include/asm/thread_info.h" 2
# 1 "./arch/arm/include/asm/page.h" 1
# 26 "./arch/arm/include/asm/page.h"
# 1 "./arch/arm/include/asm/glue.h" 1
# 27 "./arch/arm/include/asm/page.h" 2
# 110 "./arch/arm/include/asm/page.h"
struct page;
struct vm_area_struct;

struct cpu_user_fns {
 void (*cpu_clear_user_highpage)(struct page *page, unsigned long vaddr);
 void (*cpu_copy_user_highpage)(struct page *to, struct page *from,
   unsigned long vaddr, struct vm_area_struct *vma);
};


extern struct cpu_user_fns cpu_user;
# 143 "./arch/arm/include/asm/page.h"
extern void copy_page(void *to, const void *from);
# 152 "./arch/arm/include/asm/page.h"
# 1 "./arch/arm/include/asm/pgtable-2level-types.h" 1
# 24 "./arch/arm/include/asm/pgtable-2level-types.h"
typedef u32 pteval_t;
typedef u32 pmdval_t;
# 51 "./arch/arm/include/asm/pgtable-2level-types.h"
typedef pteval_t pte_t;
typedef pmdval_t pmd_t;
typedef pmdval_t pgd_t[2];
typedef pteval_t pgprot_t;
# 153 "./arch/arm/include/asm/page.h" 2




typedef struct page *pgtable_t;


extern int pfn_valid(unsigned long);


# 1 "./arch/arm/include/asm/memory.h" 1
# 19 "./arch/arm/include/asm/memory.h"
# 1 "include/linux/sizes.h" 1
# 20 "./arch/arm/include/asm/memory.h" 2
# 182 "./arch/arm/include/asm/memory.h"
extern unsigned long __pv_phys_pfn_offset;
extern u64 __pv_offset;
extern void fixup_pv_table(const void *, unsigned long);
extern const void *__pv_table_begin, *__pv_table_end;
# 223 "./arch/arm/include/asm/memory.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) phys_addr_t __virt_to_phys(unsigned long x)
{
 phys_addr_t t;

 if (sizeof(phys_addr_t) == 4) {
  __asm__("@ __pv_stub\n" "1:	" "add" "	%0, %1, %2\n" "	.pushsection .pv_table,\"a\"\n" "	.long	1b\n" "	.popsection\n" : "=r" (t) : "r" (x), "I" (0x81000000));
 } else {
  __asm__ volatile("@ __pv_stub_mov\n" "1:	mov	%R0, %1\n" "	.pushsection .pv_table,\"a\"\n" "	.long	1b\n" "	.popsection\n" : "=r" (t) : "I" (0x81));
  __asm__ volatile("@ __pv_add_carry_stub\n" "1:	adds	%Q0, %1, %2\n" "	adc	%R0, %R0, #0\n" "	.pushsection .pv_table,\"a\"\n" "	.long	1b\n" "	.popsection\n" : "+r" (t) : "r" (x), "I" (0x81000000) : "cc");
 }
 return t;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __phys_to_virt(phys_addr_t x)
{
 unsigned long t;







 __asm__("@ __pv_stub\n" "1:	" "sub" "	%0, %1, %2\n" "	.pushsection .pv_table,\"a\"\n" "	.long	1b\n" "	.popsection\n" : "=r" (t) : "r" ((unsigned long) x), "I" (0x81000000));
 return t;
}
# 278 "./arch/arm/include/asm/memory.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) phys_addr_t virt_to_phys(const volatile void *x)
{
 return __virt_to_phys((unsigned long)(x));
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *phys_to_virt(phys_addr_t x)
{
 return (void *)__phys_to_virt(x);
}
# 296 "./arch/arm/include/asm/memory.h"
extern phys_addr_t (*arch_virt_to_idmap)(unsigned long x);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) phys_addr_t __virt_to_idmap(unsigned long x)
{
 if (arch_virt_to_idmap)
  return arch_virt_to_idmap(x);
 else
  return __virt_to_phys(x);
}
# 357 "./arch/arm/include/asm/memory.h"
# 1 "include/asm-generic/memory_model.h" 1
# 358 "./arch/arm/include/asm/memory.h" 2
# 164 "./arch/arm/include/asm/page.h" 2







# 1 "include/asm-generic/getorder.h" 1
# 12 "include/asm-generic/getorder.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((__const__))
int __get_order(unsigned long size)
{
 int order;

 size--;
 size >>= 12;

 order = fls(size);



 return order;
}
# 172 "./arch/arm/include/asm/page.h" 2
# 18 "./arch/arm/include/asm/thread_info.h" 2







struct task_struct;
struct exec_domain;


# 1 "./arch/arm/include/asm/domain.h" 1
# 81 "./arch/arm/include/asm/domain.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_domain(unsigned val) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void modify_domain(unsigned dom, unsigned type) { }
# 30 "./arch/arm/include/asm/thread_info.h" 2

typedef unsigned long mm_segment_t;

struct cpu_context_save {
 __u32 r4;
 __u32 r5;
 __u32 r6;
 __u32 r7;
 __u32 r8;
 __u32 r9;
 __u32 sl;
 __u32 fp;
 __u32 sp;
 __u32 pc;
 __u32 extra[2];
};





struct thread_info {
 unsigned long flags;
 int preempt_count;
 mm_segment_t addr_limit;
 struct task_struct *task;
 struct exec_domain *exec_domain;
 __u32 cpu;
 __u32 cpu_domain;
 struct cpu_context_save cpu_context;
 __u32 syscall;
 __u8 used_cp[16];
 unsigned long tp_value[2];



 union fp_state fpstate __attribute__((aligned(8)));
 union vfp_state vfpstate;



};
# 91 "./arch/arm/include/asm/thread_info.h"
register unsigned long current_stack_pointer asm ("sp");




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct thread_info *current_thread_info(void) __attribute__((__const__));

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct thread_info *current_thread_info(void)
{
 return (struct thread_info *)
  (current_stack_pointer & ~((((1UL) << 12) << 1) - 1));
}
# 117 "./arch/arm/include/asm/thread_info.h"
extern void crunch_task_disable(struct thread_info *);
extern void crunch_task_copy(struct thread_info *, void *);
extern void crunch_task_restore(struct thread_info *, void *);
extern void crunch_task_release(struct thread_info *);

extern void iwmmxt_task_disable(struct thread_info *);
extern void iwmmxt_task_copy(struct thread_info *, void *);
extern void iwmmxt_task_restore(struct thread_info *, void *);
extern void iwmmxt_task_release(struct thread_info *);
extern void iwmmxt_task_switch(struct thread_info *);

extern void vfp_sync_hwstate(struct thread_info *);
extern void vfp_flush_hwstate(struct thread_info *);

struct user_vfp;
struct user_vfp_exc;

extern int vfp_preserve_user_clear_hwstate(struct user_vfp *,
        struct user_vfp_exc *);
extern int vfp_restore_user_hwstate(struct user_vfp *,
        struct user_vfp_exc *);
# 55 "include/linux/thread_info.h" 2
# 69 "include/linux/thread_info.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_ti_thread_flag(struct thread_info *ti, int flag)
{
 _set_bit(flag,(unsigned long *)&ti->flags);
}

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int test_ti_thread_flag(struct thread_info *ti, int flag)
{
 return test_bit(flag, (unsigned long *)&ti->flags);
}
# 125 "include/linux/thread_info.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_restore_sigmask(void)
{
 set_ti_thread_flag(current_thread_info(), 20);
 ({ int __ret_warn_on = !!(!test_ti_thread_flag(current_thread_info(), 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/thread_info.h", 128); __builtin_expect(!!(__ret_warn_on), 0); });
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void clear_restore_sigmask(void)
{
 clear_ti_thread_flag(current_thread_info(), 20);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool test_restore_sigmask(void)
{
 return test_ti_thread_flag(current_thread_info(), 20);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool test_and_clear_restore_sigmask(void)
{
 return test_and_clear_ti_thread_flag(current_thread_info(), 20);
}
# 5 "include/asm-generic/preempt.h" 2



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) int preempt_count(void)
{
 return current_thread_info()->preempt_count;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) int *preempt_count_ptr(void)
{
 return &current_thread_info()->preempt_count;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void preempt_count_set(int pc)
{
 *preempt_count_ptr() = pc;
}
# 34 "include/asm-generic/preempt.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void set_preempt_need_resched(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void clear_preempt_need_resched(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) bool test_preempt_need_resched(void)
{
 return false;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void __preempt_count_add(int val)
{
 *preempt_count_ptr() += val;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void __preempt_count_sub(int val)
{
 *preempt_count_ptr() -= val;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) bool __preempt_count_dec_and_test(void)
{





 return !--*preempt_count_ptr() && test_ti_thread_flag(current_thread_info(), 1);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) bool should_resched(void)
{
 return __builtin_expect(!!(!preempt_count() && test_ti_thread_flag(current_thread_info(), 1)), 0);
}


extern void preempt_schedule(void);
# 1 "arch/arm/include/generated/asm/preempt.h" 2
# 19 "include/linux/preempt.h" 2


extern void preempt_count_add(int val);
extern void preempt_count_sub(int val);
# 51 "include/linux/spinlock.h" 2






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




# 1 "include/linux/preempt_mask.h" 1
# 6 "include/linux/bottom_half.h" 2




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void __local_bh_disable_ip(unsigned long ip, unsigned int cnt)
{
 preempt_count_add(cnt);
 __asm__ __volatile__("": : :"memory");
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_bh_disable(void)
{
 __local_bh_disable_ip(({ __label__ __here; __here: (unsigned long)&&__here; }), (2 * (1UL << (0 + 8))));
}

extern void _local_bh_enable(void);
extern void __local_bh_enable_ip(unsigned long ip, unsigned int cnt);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_bh_enable_ip(unsigned long ip)
{
 __local_bh_enable_ip(ip, (2 * (1UL << (0 + 8))));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_bh_enable(void)
{
 __local_bh_enable_ip(({ __label__ __here; __here: (unsigned long)&&__here; }), (2 * (1UL << (0 + 8))));
}
# 58 "include/linux/spinlock.h" 2
# 81 "include/linux/spinlock.h"
# 1 "include/linux/spinlock_types.h" 1
# 13 "include/linux/spinlock_types.h"
# 1 "./arch/arm/include/asm/spinlock_types.h" 1
# 10 "./arch/arm/include/asm/spinlock_types.h"
typedef struct {
 union {
  u32 slock;
  struct __raw_tickets {




   u16 owner;
   u16 next;

  } tickets;
 };
} arch_spinlock_t;



typedef struct {
 u32 lock;
} arch_rwlock_t;
# 14 "include/linux/spinlock_types.h" 2




# 1 "include/linux/lockdep.h" 1
# 12 "include/linux/lockdep.h"
struct task_struct;
struct lockdep_map;


extern int prove_locking;
extern int lock_stat;
# 373 "include/linux/lockdep.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void lockdep_off(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void lockdep_on(void)
{
}
# 414 "include/linux/lockdep.h"
struct lock_class_key { };
# 469 "include/linux/lockdep.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void print_irqtrace_events(struct task_struct *curr)
{
}
# 537 "include/linux/lockdep.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
lockdep_rcu_suspicious(const char *file, const int line, const char *s)
{
}
# 19 "include/linux/spinlock_types.h" 2

typedef struct raw_spinlock {
 arch_spinlock_t raw_lock;




 unsigned int magic, owner_cpu;
 void *owner;




} raw_spinlock_t;
# 64 "include/linux/spinlock_types.h"
typedef struct spinlock {
 union {
  struct raw_spinlock rlock;
# 75 "include/linux/spinlock_types.h"
 };
} spinlock_t;
# 86 "include/linux/spinlock_types.h"
# 1 "include/linux/rwlock_types.h" 1
# 11 "include/linux/rwlock_types.h"
typedef struct {
 arch_rwlock_t raw_lock;




 unsigned int magic, owner_cpu;
 void *owner;




} rwlock_t;
# 87 "include/linux/spinlock_types.h" 2
# 82 "include/linux/spinlock.h" 2





# 1 "./arch/arm/include/asm/spinlock.h" 1







# 1 "include/linux/prefetch.h" 1
# 14 "include/linux/prefetch.h"
# 1 "./arch/arm/include/asm/processor.h" 1
# 22 "./arch/arm/include/asm/processor.h"
# 1 "./arch/arm/include/asm/hw_breakpoint.h" 1





struct task_struct;
# 135 "./arch/arm/include/asm/hw_breakpoint.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void clear_ptrace_hw_breakpoint(struct task_struct *tsk) {}
# 23 "./arch/arm/include/asm/processor.h" 2


# 1 "./arch/arm/include/asm/unified.h" 1
# 107 "./arch/arm/include/asm/unified.h"
__asm__(
"	.macro	it, cond\n"
"	.endm\n"
"	.macro	itt, cond\n"
"	.endm\n"
"	.macro	ite, cond\n"
"	.endm\n"
"	.macro	ittt, cond\n"
"	.endm\n"
"	.macro	itte, cond\n"
"	.endm\n"
"	.macro	itet, cond\n"
"	.endm\n"
"	.macro	itee, cond\n"
"	.endm\n"
"	.macro	itttt, cond\n"
"	.endm\n"
"	.macro	ittte, cond\n"
"	.endm\n"
"	.macro	ittet, cond\n"
"	.endm\n"
"	.macro	ittee, cond\n"
"	.endm\n"
"	.macro	itett, cond\n"
"	.endm\n"
"	.macro	itete, cond\n"
"	.endm\n"
"	.macro	iteet, cond\n"
"	.endm\n"
"	.macro	iteee, cond\n"
"	.endm\n");
# 26 "./arch/arm/include/asm/processor.h" 2







struct debug_info {



};

struct thread_struct {

 unsigned long address;
 unsigned long trap_no;
 unsigned long error_code;

 struct debug_info debug;
};
# 72 "./arch/arm/include/asm/processor.h"
struct task_struct;


extern void release_thread(struct task_struct *);

unsigned long get_wchan(struct task_struct *p);
# 110 "./arch/arm/include/asm/processor.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void prefetch(const void *ptr)
{
 __asm__ __volatile__(
  "pld\t%a0"
  :: "p" (ptr));
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void prefetchw(const void *ptr)
{
 __asm__ __volatile__(
  ".arch_extension	mp\n"
  "9998:	" "pldw" "\t%a0" "\n" "	.pushsection \".alt.smp.init\", \"a\"\n" "	.long	9998b\n" "	" "pld" "\t%a0" "\n" "	.popsection\n"



  :: "p" (ptr));
}
# 15 "include/linux/prefetch.h" 2
# 53 "include/linux/prefetch.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void prefetch_range(void *addr, size_t len)
{

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

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

}
# 9 "./arch/arm/include/asm/spinlock.h" 2
# 38 "./arch/arm/include/asm/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void dsb_sev(void)
{

 __asm__ __volatile__ ("dsb " "ishst" : : : "memory");
 __asm__("9998:	" "sev" "\n" "	.pushsection \".alt.smp.init\", \"a\"\n" "	.long	9998b\n" "	" "nop" "\n" "	.popsection\n");
}
# 58 "./arch/arm/include/asm/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_spin_lock(arch_spinlock_t *lock)
{
 unsigned long tmp;
 u32 newval;
 arch_spinlock_t lockval;

 prefetchw(&lock->slock);
 __asm__ __volatile__(
"1:	ldrex	%0, [%3]\n"
"	add	%1, %0, %4\n"
"	strex	%2, %1, [%3]\n"
"	teq	%2, #0\n"
"	bne	1b"
 : "=&r" (lockval), "=&r" (newval), "=&r" (tmp)
 : "r" (&lock->slock), "I" (1 << 16)
 : "cc");

 while (lockval.tickets.next != lockval.tickets.owner) {
  __asm__ __volatile__ ("wfe" : : : "memory");
  lockval.tickets.owner = (*({ __attribute__((unused)) typeof(lock->tickets.owner) __var = ( typeof(lock->tickets.owner)) 0; (volatile typeof(lock->tickets.owner) *)&(lock->tickets.owner); }));
 }

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_spin_trylock(arch_spinlock_t *lock)
{
 unsigned long contended, res;
 u32 slock;

 prefetchw(&lock->slock);
 do {
  __asm__ __volatile__(
  "	ldrex	%0, [%3]\n"
  "	mov	%2, #0\n"
  "	subs	%1, %0, %0, ror #16\n"
  "	addeq	%0, %0, %4\n"
  "	strexeq	%2, %0, [%3]"
  : "=&r" (slock), "=&r" (contended), "=&r" (res)
  : "r" (&lock->slock), "I" (1 << 16)
  : "cc");
 } while (res);

 if (!contended) {
  __asm__ __volatile__ ("dmb " "ish" : : : "memory");
  return 1;
 } else {
  return 0;
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_spin_unlock(arch_spinlock_t *lock)
{
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 lock->tickets.owner++;
 dsb_sev();
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_spin_value_unlocked(arch_spinlock_t lock)
{
 return lock.tickets.owner == lock.tickets.next;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_spin_is_locked(arch_spinlock_t *lock)
{
 return !arch_spin_value_unlocked(({ union { typeof(*lock) __val; char __c[1]; } __u; __read_once_size(&(*lock), __u.__c, sizeof(*lock)); __u.__val; }));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_spin_is_contended(arch_spinlock_t *lock)
{
 struct __raw_tickets tickets = ({ union { typeof(lock->tickets) __val; char __c[1]; } __u; __read_once_size(&(lock->tickets), __u.__c, sizeof(lock->tickets)); __u.__val; });
 return (tickets.next - tickets.owner) > 1;
}
# 141 "./arch/arm/include/asm/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_write_lock(arch_rwlock_t *rw)
{
 unsigned long tmp;

 prefetchw(&rw->lock);
 __asm__ __volatile__(
"1:	ldrex	%0, [%1]\n"
"	teq	%0, #0\n"
 "9998:	" "wfe" "ne" "\n" "	.pushsection \".alt.smp.init\", \"a\"\n" "	.long	9998b\n" "	" "nop" "\n" "	.popsection\n"
"	strexeq	%0, %2, [%1]\n"
"	teq	%0, #0\n"
"	bne	1b"
 : "=&r" (tmp)
 : "r" (&rw->lock), "r" (0x80000000)
 : "cc");

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_write_trylock(arch_rwlock_t *rw)
{
 unsigned long contended, res;

 prefetchw(&rw->lock);
 do {
  __asm__ __volatile__(
  "	ldrex	%0, [%2]\n"
  "	mov	%1, #0\n"
  "	teq	%0, #0\n"
  "	strexeq	%1, %3, [%2]"
  : "=&r" (contended), "=&r" (res)
  : "r" (&rw->lock), "r" (0x80000000)
  : "cc");
 } while (res);

 if (!contended) {
  __asm__ __volatile__ ("dmb " "ish" : : : "memory");
  return 1;
 } else {
  return 0;
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_write_unlock(arch_rwlock_t *rw)
{
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 __asm__ __volatile__(
 "str	%1, [%0]\n"
 :
 : "r" (&rw->lock), "r" (0)
 : "cc");

 dsb_sev();
}
# 212 "./arch/arm/include/asm/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_read_lock(arch_rwlock_t *rw)
{
 unsigned long tmp, tmp2;

 prefetchw(&rw->lock);
 __asm__ __volatile__(
"1:	ldrex	%0, [%2]\n"
"	adds	%0, %0, #1\n"
"	strexpl	%1, %0, [%2]\n"
 "9998:	" "wfe" "mi" "\n" "	.pushsection \".alt.smp.init\", \"a\"\n" "	.long	9998b\n" "	" "nop" "\n" "	.popsection\n"
"	rsbpls	%0, %1, #0\n"
"	bmi	1b"
 : "=&r" (tmp), "=&r" (tmp2)
 : "r" (&rw->lock)
 : "cc");

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_read_unlock(arch_rwlock_t *rw)
{
 unsigned long tmp, tmp2;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 prefetchw(&rw->lock);
 __asm__ __volatile__(
"1:	ldrex	%0, [%2]\n"
"	sub	%0, %0, #1\n"
"	strex	%1, %0, [%2]\n"
"	teq	%1, #0\n"
"	bne	1b"
 : "=&r" (tmp), "=&r" (tmp2)
 : "r" (&rw->lock)
 : "cc");

 if (tmp == 0)
  dsb_sev();
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int arch_read_trylock(arch_rwlock_t *rw)
{
 unsigned long contended, res;

 prefetchw(&rw->lock);
 do {
  __asm__ __volatile__(
  "	ldrex	%0, [%2]\n"
  "	mov	%1, #0\n"
  "	adds	%0, %0, #1\n"
  "	strexpl	%1, %0, [%2]"
  : "=&r" (contended), "=&r" (res)
  : "r" (&rw->lock)
  : "cc");
 } while (res);


 if (contended < 0x80000000) {
  __asm__ __volatile__ ("dmb " "ish" : : : "memory");
  return 1;
 } else {
  return 0;
 }
}
# 88 "include/linux/spinlock.h" 2





  extern void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name,
       struct lock_class_key *key);
# 150 "include/linux/spinlock.h"
 extern void do_raw_spin_lock(raw_spinlock_t *lock) ;

 extern int do_raw_spin_trylock(raw_spinlock_t *lock);
 extern void do_raw_spin_unlock(raw_spinlock_t *lock) ;
# 284 "include/linux/spinlock.h"
# 1 "include/linux/rwlock.h" 1
# 18 "include/linux/rwlock.h"
  extern void __rwlock_init(rwlock_t *lock, const char *name,
       struct lock_class_key *key);
# 32 "include/linux/rwlock.h"
 extern void do_raw_read_lock(rwlock_t *lock) ;

 extern int do_raw_read_trylock(rwlock_t *lock);
 extern void do_raw_read_unlock(rwlock_t *lock) ;
 extern void do_raw_write_lock(rwlock_t *lock) ;

 extern int do_raw_write_trylock(rwlock_t *lock);
 extern void do_raw_write_unlock(rwlock_t *lock) ;
# 285 "include/linux/spinlock.h" 2





# 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"))) _raw_spin_lock(raw_spinlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)
        ;
void __attribute__((section(".spinlock.text"))) _raw_spin_lock_bh_nested(raw_spinlock_t *lock, int subclass)
        ;
void __attribute__((section(".spinlock.text")))
_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map)
        ;
void __attribute__((section(".spinlock.text"))) _raw_spin_lock_bh(raw_spinlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_spin_lock_irq(raw_spinlock_t *lock)
        ;

unsigned long __attribute__((section(".spinlock.text"))) _raw_spin_lock_irqsave(raw_spinlock_t *lock)
        ;
unsigned long __attribute__((section(".spinlock.text")))
_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass)
        ;
int __attribute__((section(".spinlock.text"))) _raw_spin_trylock(raw_spinlock_t *lock);
int __attribute__((section(".spinlock.text"))) _raw_spin_trylock_bh(raw_spinlock_t *lock);
void __attribute__((section(".spinlock.text"))) _raw_spin_unlock(raw_spinlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_spin_unlock_bh(raw_spinlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_spin_unlock_irq(raw_spinlock_t *lock) ;
void __attribute__((section(".spinlock.text")))
_raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
        ;
# 88 "include/linux/spinlock_api_smp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __raw_spin_trylock(raw_spinlock_t *lock)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 if (do_raw_spin_trylock(lock)) {
  do { } while (0);
  return 1;
 }
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
 return 0;
}
# 106 "include/linux/spinlock_api_smp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
# 121 "include/linux/spinlock_api_smp.h"
 do_raw_spin_lock(lock);

 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_lock_irq(raw_spinlock_t *lock)
{
 do { arch_local_irq_disable(); } while (0);
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_spin_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_lock_bh(raw_spinlock_t *lock)
{
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
 do { } while (0);
 do_raw_spin_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_lock(raw_spinlock_t *lock)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_spin_lock(lock);
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_unlock(raw_spinlock_t *lock)
{
 do { } while (0);
 do_raw_spin_unlock(lock);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,
         unsigned long flags)
{
 do { } while (0);
 do_raw_spin_unlock(lock);
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } while (0);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_unlock_irq(raw_spinlock_t *lock)
{
 do { } while (0);
 do_raw_spin_unlock(lock);
 do { arch_local_irq_enable(); } while (0);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_spin_unlock_bh(raw_spinlock_t *lock)
{
 do { } while (0);
 do_raw_spin_unlock(lock);
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __raw_spin_trylock_bh(raw_spinlock_t *lock)
{
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
 if (do_raw_spin_trylock(lock)) {
  do { } while (0);
  return 1;
 }
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
 return 0;
}

# 1 "include/linux/rwlock_api_smp.h" 1
# 18 "include/linux/rwlock_api_smp.h"
void __attribute__((section(".spinlock.text"))) _raw_read_lock(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_write_lock(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_read_lock_bh(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_write_lock_bh(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_read_lock_irq(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_write_lock_irq(rwlock_t *lock) ;
unsigned long __attribute__((section(".spinlock.text"))) _raw_read_lock_irqsave(rwlock_t *lock)
       ;
unsigned long __attribute__((section(".spinlock.text"))) _raw_write_lock_irqsave(rwlock_t *lock)
       ;
int __attribute__((section(".spinlock.text"))) _raw_read_trylock(rwlock_t *lock);
int __attribute__((section(".spinlock.text"))) _raw_write_trylock(rwlock_t *lock);
void __attribute__((section(".spinlock.text"))) _raw_read_unlock(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_write_unlock(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_read_unlock_bh(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_write_unlock_bh(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_read_unlock_irq(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text"))) _raw_write_unlock_irq(rwlock_t *lock) ;
void __attribute__((section(".spinlock.text")))
_raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
       ;
void __attribute__((section(".spinlock.text")))
_raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
       ;
# 117 "include/linux/rwlock_api_smp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __raw_read_trylock(rwlock_t *lock)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 if (do_raw_read_trylock(lock)) {
  do { } while (0);
  return 1;
 }
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __raw_write_trylock(rwlock_t *lock)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 if (do_raw_write_trylock(lock)) {
  do { } while (0);
  return 1;
 }
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
 return 0;
}
# 146 "include/linux/rwlock_api_smp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_read_lock(rwlock_t *lock)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_read_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_read_lock((lock))
                                       ;
 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_read_lock_irq(rwlock_t *lock)
{
 do { arch_local_irq_disable(); } while (0);
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_read_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_read_lock_bh(rwlock_t *lock)
{
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
 do { } while (0);
 do_raw_read_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_write_lock((lock))
                                        ;
 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_lock_irq(rwlock_t *lock)
{
 do { arch_local_irq_disable(); } while (0);
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_write_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_lock_bh(rwlock_t *lock)
{
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
 do { } while (0);
 do_raw_write_lock(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_lock(rwlock_t *lock)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 do { } while (0);
 do_raw_write_lock(lock);
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_unlock(rwlock_t *lock)
{
 do { } while (0);
 do_raw_write_unlock(lock);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_read_unlock(rwlock_t *lock)
{
 do { } while (0);
 do_raw_read_unlock(lock);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
{
 do { } while (0);
 do_raw_read_unlock(lock);
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } while (0);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_read_unlock_irq(rwlock_t *lock)
{
 do { } while (0);
 do_raw_read_unlock(lock);
 do { arch_local_irq_enable(); } while (0);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_read_unlock_bh(rwlock_t *lock)
{
 do { } while (0);
 do_raw_read_unlock(lock);
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_unlock_irqrestore(rwlock_t *lock,
          unsigned long flags)
{
 do { } while (0);
 do_raw_write_unlock(lock);
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } while (0);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_unlock_irq(rwlock_t *lock)
{
 do { } while (0);
 do_raw_write_unlock(lock);
 do { arch_local_irq_enable(); } while (0);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __raw_write_unlock_bh(rwlock_t *lock)
{
 do { } while (0);
 do_raw_write_unlock(lock);
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + 1));
}
# 193 "include/linux/spinlock_api_smp.h" 2
# 291 "include/linux/spinlock.h" 2
# 299 "include/linux/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) raw_spinlock_t *spinlock_check(spinlock_t *lock)
{
 return &lock->rlock;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_lock(spinlock_t *lock)
{
 _raw_spin_lock(&lock->rlock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_lock_bh(spinlock_t *lock)
{
 _raw_spin_lock_bh(&lock->rlock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_trylock(spinlock_t *lock)
{
 return (_raw_spin_trylock(&lock->rlock));
}
# 340 "include/linux/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_lock_irq(spinlock_t *lock)
{
 _raw_spin_lock_irq(&lock->rlock);
}
# 355 "include/linux/spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_unlock(spinlock_t *lock)
{
 _raw_spin_unlock(&lock->rlock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_unlock_bh(spinlock_t *lock)
{
 _raw_spin_unlock_bh(&lock->rlock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_unlock_irq(spinlock_t *lock)
{
 _raw_spin_unlock_irq(&lock->rlock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
{
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _raw_spin_unlock_irqrestore(&lock->rlock, flags); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_trylock_bh(spinlock_t *lock)
{
 return (_raw_spin_trylock_bh(&lock->rlock));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_trylock_irq(spinlock_t *lock)
{
 return ({ do { arch_local_irq_disable(); } while (0); (_raw_spin_trylock(&lock->rlock)) ? 1 : ({ do { arch_local_irq_enable(); } while (0); 0; }); });
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void spin_unlock_wait(spinlock_t *lock)
{
 do { while (arch_spin_is_locked(&(&lock->rlock)->raw_lock)) __asm__ __volatile__("": : :"memory"); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_is_locked(spinlock_t *lock)
{
 return arch_spin_is_locked(&(&lock->rlock)->raw_lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_is_contended(spinlock_t *lock)
{
 return arch_spin_is_contended(&(&lock->rlock)->raw_lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_can_lock(spinlock_t *lock)
{
 return (!arch_spin_is_locked(&(&lock->rlock)->raw_lock));
}







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



# 1 "./arch/arm/include/asm/atomic.h" 1
# 19 "./arch/arm/include/asm/atomic.h"
# 1 "./arch/arm/include/asm/cmpxchg.h" 1
# 27 "./arch/arm/include/asm/cmpxchg.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
{
 extern void __bad_xchg(volatile void *, int);
 unsigned long ret;




 unsigned int tmp;


 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw((const void *)ptr);

 switch (size) {

 case 1:
  asm volatile("@	__xchg1\n"
  "1:	ldrexb	%0, [%3]\n"
  "	strexb	%1, %2, [%3]\n"
  "	teq	%1, #0\n"
  "	bne	1b"
   : "=&r" (ret), "=&r" (tmp)
   : "r" (x), "r" (ptr)
   : "memory", "cc");
  break;
 case 4:
  asm volatile("@	__xchg4\n"
  "1:	ldrex	%0, [%3]\n"
  "	strex	%1, %2, [%3]\n"
  "	teq	%1, #0\n"
  "	bne	1b"
   : "=&r" (ret), "=&r" (tmp)
   : "r" (x), "r" (ptr)
   : "memory", "cc");
  break;
# 96 "./arch/arm/include/asm/cmpxchg.h"
 default:
  __bad_xchg(ptr, size), ret = 0;
  break;
 }
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return ret;
}




# 1 "include/asm-generic/cmpxchg-local.h" 1






extern unsigned long wrong_size_cmpxchg(volatile void *ptr)
 __attribute__((noreturn));





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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; }); flags = arch_local_irq_save(); } 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; }); arch_local_irq_restore(flags); } while (0);
 return prev;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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; }); flags = arch_local_irq_save(); } while (0);
 prev = *(u64 *)ptr;
 if (prev == old)
  *(u64 *)ptr = new;
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0);
 return prev;
}
# 109 "./arch/arm/include/asm/cmpxchg.h" 2
# 132 "./arch/arm/include/asm/cmpxchg.h"
extern void __bad_cmpxchg(volatile void *ptr, int size);





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
          unsigned long new, int size)
{
 unsigned long oldval, res;

 prefetchw((const void *)ptr);

 switch (size) {

 case 1:
  do {
   asm volatile("@ __cmpxchg1\n"
   "	ldrexb	%1, [%2]\n"
   "	mov	%0, #0\n"
   "	teq	%1, %3\n"
   "	strexbeq %0, %4, [%2]\n"
    : "=&r" (res), "=&r" (oldval)
    : "r" (ptr), "Ir" (old), "r" (new)
    : "memory", "cc");
  } while (res);
  break;
 case 2:
  do {
   asm volatile("@ __cmpxchg1\n"
   "	ldrexh	%1, [%2]\n"
   "	mov	%0, #0\n"
   "	teq	%1, %3\n"
   "	strexheq %0, %4, [%2]\n"
    : "=&r" (res), "=&r" (oldval)
    : "r" (ptr), "Ir" (old), "r" (new)
    : "memory", "cc");
  } while (res);
  break;

 case 4:
  do {
   asm volatile("@ __cmpxchg4\n"
   "	ldrex	%1, [%2]\n"
   "	mov	%0, #0\n"
   "	teq	%1, %3\n"
   "	strexeq %0, %4, [%2]\n"
    : "=&r" (res), "=&r" (oldval)
    : "r" (ptr), "Ir" (old), "r" (new)
    : "memory", "cc");
  } while (res);
  break;
 default:
  __bad_cmpxchg(ptr, size);
  oldval = 0;
 }

 return oldval;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __cmpxchg_mb(volatile void *ptr, unsigned long old,
      unsigned long new, int size)
{
 unsigned long ret;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 ret = __cmpxchg(ptr, old, new, size);
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return ret;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __cmpxchg_local(volatile void *ptr,
         unsigned long old,
         unsigned long new, int size)
{
 unsigned long ret;

 switch (size) {






 default:
  ret = __cmpxchg(ptr, old, new, size);
 }

 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long long __cmpxchg64(unsigned long long *ptr,
          unsigned long long old,
          unsigned long long new)
{
 unsigned long long oldval;
 unsigned long res;

 prefetchw(ptr);

 __asm__ __volatile__(
"1:	ldrexd		%1, %H1, [%3]\n"
"	teq		%1, %4\n"
"	teqeq		%H1, %H4\n"
"	bne		2f\n"
"	strexd		%0, %5, %H5, [%3]\n"
"	teq		%0, #0\n"
"	bne		1b\n"
"2:"
 : "=&r" (res), "=&r" (oldval), "+Qo" (*ptr)
 : "r" (ptr), "r" (old), "r" (new)
 : "cc");

 return oldval;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long long __cmpxchg64_mb(unsigned long long *ptr,
      unsigned long long old,
      unsigned long long new)
{
 unsigned long long ret;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 ret = __cmpxchg64(ptr, old, new);
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return ret;
}
# 20 "./arch/arm/include/asm/atomic.h" 2
# 83 "./arch/arm/include/asm/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_cmpxchg(atomic_t *ptr, int old, int new)
{
 int oldval;
 unsigned long res;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw(&ptr->counter);

 do {
  __asm__ __volatile__("@ atomic_cmpxchg\n"
  "ldrex	%1, [%3]\n"
  "mov	%0, #0\n"
  "teq	%1, %4\n"
  "strexeq %0, %5, [%3]\n"
      : "=&r" (res), "=&r" (oldval), "+Qo" (ptr->counter)
      : "r" (&ptr->counter), "Ir" (old), "r" (new)
      : "cc");
 } while (res);

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return oldval;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __atomic_add_unless(atomic_t *v, int a, int u)
{
 int oldval, newval;
 unsigned long tmp;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw(&v->counter);

 __asm__ __volatile__ ("@ atomic_add_unless\n"
"1:	ldrex	%0, [%4]\n"
"	teq	%0, %5\n"
"	beq	2f\n"
"	add	%1, %0, %6\n"
"	strex	%2, %1, [%4]\n"
"	teq	%2, #0\n"
"	bne	1b\n"
"2:"
 : "=&r" (oldval), "=&r" (newval), "=&r" (tmp), "+Qo" (v->counter)
 : "r" (&v->counter), "r" (u), "r" (a)
 : "cc");

 if (oldval != u)
  __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return oldval;
}
# 194 "./arch/arm/include/asm/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void atomic_add(int i, atomic_t *v) { unsigned long tmp; int result; prefetchw(&v->counter); __asm__ __volatile__("@ atomic_" "add" "\n" "1:	ldrex	%0, [%3]\n" "	" "add" "	%0, %0, %4\n" "	strex	%1, %0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "Ir" (i) : "cc"); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_add_return(int i, atomic_t *v) { unsigned long tmp; int result; __asm__ __volatile__ ("dmb " "ish" : : : "memory"); prefetchw(&v->counter); __asm__ __volatile__("@ atomic_" "add" "_return\n" "1:	ldrex	%0, [%3]\n" "	" "add" "	%0, %0, %4\n" "	strex	%1, %0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "Ir" (i) : "cc"); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); return result; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void atomic_sub(int i, atomic_t *v) { unsigned long tmp; int result; prefetchw(&v->counter); __asm__ __volatile__("@ atomic_" "sub" "\n" "1:	ldrex	%0, [%3]\n" "	" "sub" "	%0, %0, %4\n" "	strex	%1, %0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "Ir" (i) : "cc"); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_sub_return(int i, atomic_t *v) { unsigned long tmp; int result; __asm__ __volatile__ ("dmb " "ish" : : : "memory"); prefetchw(&v->counter); __asm__ __volatile__("@ atomic_" "sub" "_return\n" "1:	ldrex	%0, [%3]\n" "	" "sub" "	%0, %0, %4\n" "	strex	%1, %0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "Ir" (i) : "cc"); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); return result; }
# 215 "./arch/arm/include/asm/atomic.h"
typedef struct {
 long long counter;
} atomic64_t;
# 244 "./arch/arm/include/asm/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long long atomic64_read(const atomic64_t *v)
{
 long long result;

 __asm__ __volatile__("@ atomic64_read\n"
"	ldrexd	%0, %H0, [%1]"
 : "=&r" (result)
 : "r" (&v->counter), "Qo" (v->counter)
 );

 return result;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void atomic64_set(atomic64_t *v, long long i)
{
 long long tmp;

 prefetchw(&v->counter);
 __asm__ __volatile__("@ atomic64_set\n"
"1:	ldrexd	%0, %H0, [%2]\n"
"	strexd	%0, %3, %H3, [%2]\n"
"	teq	%0, #0\n"
"	bne	1b"
 : "=&r" (tmp), "=Qo" (v->counter)
 : "r" (&v->counter), "r" (i)
 : "cc");
}
# 321 "./arch/arm/include/asm/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void atomic64_add(long long i, atomic64_t *v) { long long result; unsigned long tmp; prefetchw(&v->counter); __asm__ __volatile__("@ atomic64_" "add" "\n" "1:	ldrexd	%0, %H0, [%3]\n" "	" "adds" " %Q0, %Q0, %Q4\n" "	" "adc" " %R0, %R0, %R4\n" "	strexd	%1, %0, %H0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "r" (i) : "cc"); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long long atomic64_add_return(long long i, atomic64_t *v) { long long result; unsigned long tmp; __asm__ __volatile__ ("dmb " "ish" : : : "memory"); prefetchw(&v->counter); __asm__ __volatile__("@ atomic64_" "add" "_return\n" "1:	ldrexd	%0, %H0, [%3]\n" "	" "adds" " %Q0, %Q0, %Q4\n" "	" "adc" " %R0, %R0, %R4\n" "	strexd	%1, %0, %H0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "r" (i) : "cc"); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); return result; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void atomic64_sub(long long i, atomic64_t *v) { long long result; unsigned long tmp; prefetchw(&v->counter); __asm__ __volatile__("@ atomic64_" "sub" "\n" "1:	ldrexd	%0, %H0, [%3]\n" "	" "subs" " %Q0, %Q0, %Q4\n" "	" "sbc" " %R0, %R0, %R4\n" "	strexd	%1, %0, %H0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "r" (i) : "cc"); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long long atomic64_sub_return(long long i, atomic64_t *v) { long long result; unsigned long tmp; __asm__ __volatile__ ("dmb " "ish" : : : "memory"); prefetchw(&v->counter); __asm__ __volatile__("@ atomic64_" "sub" "_return\n" "1:	ldrexd	%0, %H0, [%3]\n" "	" "subs" " %Q0, %Q0, %Q4\n" "	" "sbc" " %R0, %R0, %R4\n" "	strexd	%1, %0, %H0, [%3]\n" "	teq	%1, #0\n" "	bne	1b" : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter) : "r" (&v->counter), "r" (i) : "cc"); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); return result; }





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long long atomic64_cmpxchg(atomic64_t *ptr, long long old,
     long long new)
{
 long long oldval;
 unsigned long res;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw(&ptr->counter);

 do {
  __asm__ __volatile__("@ atomic64_cmpxchg\n"
  "ldrexd		%1, %H1, [%3]\n"
  "mov		%0, #0\n"
  "teq		%1, %4\n"
  "teqeq		%H1, %H4\n"
  "strexdeq	%0, %5, %H5, [%3]"
  : "=&r" (res), "=&r" (oldval), "+Qo" (ptr->counter)
  : "r" (&ptr->counter), "r" (old), "r" (new)
  : "cc");
 } while (res);

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return oldval;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long long atomic64_xchg(atomic64_t *ptr, long long new)
{
 long long result;
 unsigned long tmp;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw(&ptr->counter);

 __asm__ __volatile__("@ atomic64_xchg\n"
"1:	ldrexd	%0, %H0, [%3]\n"
"	strexd	%1, %4, %H4, [%3]\n"
"	teq	%1, #0\n"
"	bne	1b"
 : "=&r" (result), "=&r" (tmp), "+Qo" (ptr->counter)
 : "r" (&ptr->counter), "r" (new)
 : "cc");

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return result;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long long atomic64_dec_if_positive(atomic64_t *v)
{
 long long result;
 unsigned long tmp;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw(&v->counter);

 __asm__ __volatile__("@ atomic64_dec_if_positive\n"
"1:	ldrexd	%0, %H0, [%3]\n"
"	subs	%Q0, %Q0, #1\n"
"	sbc	%R0, %R0, #0\n"
"	teq	%R0, #0\n"
"	bmi	2f\n"
"	strexd	%1, %0, %H0, [%3]\n"
"	teq	%1, #0\n"
"	bne	1b\n"
"2:"
 : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
 : "r" (&v->counter)
 : "cc");

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return result;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic64_add_unless(atomic64_t *v, long long a, long long u)
{
 long long val;
 unsigned long tmp;
 int ret = 1;

 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 prefetchw(&v->counter);

 __asm__ __volatile__("@ atomic64_add_unless\n"
"1:	ldrexd	%0, %H0, [%4]\n"
"	teq	%0, %5\n"
"	teqeq	%H0, %H5\n"
"	moveq	%1, #0\n"
"	beq	2f\n"
"	adds	%Q0, %Q0, %Q6\n"
"	adc	%R0, %R0, %R6\n"
"	strexd	%2, %0, %H0, [%4]\n"
"	teq	%2, #0\n"
"	bne	1b\n"
"2:"
 : "=&r" (val), "+r" (ret), "=&r" (tmp), "+Qo" (v->counter)
 : "r" (&v->counter), "r" (u), "r" (a)
 : "cc");

 if (ret)
  __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return ret;
}
# 5 "include/linux/atomic.h" 2
# 15 "include/linux/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_add_unless(atomic_t *v, int a, int u)
{
 return __atomic_add_unless(v, a, u) != u;
}
# 44 "include/linux/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_inc_not_zero_hint(atomic_t *v, int hint)
{
 int val, c = hint;


 if (!hint)
  return atomic_add_unless((v), 1, 0);

 do {
  val = atomic_cmpxchg(v, c, c + 1);
  if (val == c)
   return 1;
  c = val;
 } while (c);

 return 0;
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_inc_unless_negative(atomic_t *p)
{
 int v, v1;
 for (v = 0; v >= 0; v = v1) {
  v1 = atomic_cmpxchg(p, v, v + 1);
  if (__builtin_expect(!!(v1 == v), 1))
   return 1;
 }
 return 0;
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_dec_unless_positive(atomic_t *p)
{
 int v, v1;
 for (v = 0; v <= 0; v = v1) {
  v1 = atomic_cmpxchg(p, v, v - 1);
  if (__builtin_expect(!!(v1 == v), 1))
   return 1;
 }
 return 0;
}
# 97 "include/linux/atomic.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int atomic_dec_if_positive(atomic_t *v)
{
 int c, old, dec;
 c = (*({ __attribute__((unused)) typeof((v)->counter) __var = ( typeof((v)->counter)) 0; (volatile typeof((v)->counter) *)&((v)->counter); }));
 for (;;) {
  dec = c - 1;
  if (__builtin_expect(!!(dec < 0), 0))
   break;
  old = atomic_cmpxchg((v), c, dec);
  if (__builtin_expect(!!(old == c), 1))
   break;
  c = old;
 }
 return dec;
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void atomic_or(int i, atomic_t *v)
{
 int old;
 int new;

 do {
  old = (*({ __attribute__((unused)) typeof((v)->counter) __var = ( typeof((v)->counter)) 0; (volatile typeof((v)->counter) *)&((v)->counter); }));
  new = old | i;
 } while (atomic_cmpxchg(v, old, new) != old);
}


# 1 "include/asm-generic/atomic-long.h" 1
# 141 "include/asm-generic/atomic-long.h"
typedef atomic_t atomic_long_t;


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

 return (long)(*({ __attribute__((unused)) typeof((v)->counter) __var = ( typeof((v)->counter)) 0; (volatile typeof((v)->counter) *)&((v)->counter); }));
}

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

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

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

 atomic_add(1, v);
}

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

 atomic_sub(1, v);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int atomic_long_add_negative(long i, atomic_long_t *l)
{
 atomic_t *v = (atomic_t *)l;

 return (atomic_add_return(i, v) < 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) long atomic_long_add_unless(atomic_long_t *l, long a, long u)
{
 atomic_t *v = (atomic_t *)l;

 return (long)atomic_add_unless(v, a, u);
}
# 128 "include/linux/atomic.h" 2
# 417 "include/linux/spinlock.h" 2
# 425 "include/linux/spinlock.h"
extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
# 8 "include/linux/mmzone.h" 2

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






# 1 "include/linux/stddef.h" 1
# 8 "include/linux/wait.h" 2

# 1 "arch/arm/include/generated/asm/current.h" 1
# 1 "include/asm-generic/current.h" 1
# 1 "arch/arm/include/generated/asm/current.h" 2
# 10 "include/linux/wait.h" 2
# 1 "include/uapi/linux/wait.h" 1
# 11 "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;

 unsigned long timeout;
};

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;
# 72 "include/linux/wait.h"
extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
# 90 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void
__add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
{
 wait->flags |= 0x01;
 __add_wait_queue(q, wait);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void
__add_wait_queue_tail_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
{
 wait->flags |= 0x01;
 __add_wait_queue_tail(q, wait);
}

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

typedef int wait_bit_action_f(struct wait_bit_key *);
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, int nr);
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 *, wait_bit_action_f *, unsigned);
int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, wait_bit_action_f *, unsigned);
void wake_up_bit(void *, int);
void wake_up_atomic_t(atomic_t *);
int out_of_line_wait_on_bit(void *, int, wait_bit_action_f *, unsigned);
int out_of_line_wait_on_bit_timeout(void *, int, wait_bit_action_f *, unsigned, unsigned long);
int out_of_line_wait_on_bit_lock(void *, int, wait_bit_action_f *, unsigned);
int out_of_line_wait_on_atomic_t(atomic_t *, int (*)(atomic_t *), unsigned);
wait_queue_head_t *bit_waitqueue(void *, int);
# 911 "include/linux/wait.h"
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);
long prepare_to_wait_event(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);
long wait_woken(wait_queue_t *wait, unsigned mode, long timeout);
int woken_wake_function(wait_queue_t *wait, unsigned mode, int sync, 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);
# 950 "include/linux/wait.h"
extern int bit_wait(struct wait_bit_key *);
extern int bit_wait_io(struct wait_bit_key *);
extern int bit_wait_timeout(struct wait_bit_key *);
extern int bit_wait_io_timeout(struct wait_bit_key *);
# 971 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit(void *word, int bit, unsigned mode)
{
 do { do { } while (0); } while (0);
 if (!test_bit(bit, word))
  return 0;
 return out_of_line_wait_on_bit(word, bit,
           bit_wait,
           mode);
}
# 996 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit_io(void *word, int bit, unsigned mode)
{
 do { do { } while (0); } while (0);
 if (!test_bit(bit, word))
  return 0;
 return out_of_line_wait_on_bit(word, bit,
           bit_wait_io,
           mode);
}
# 1022 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit_timeout(void *word, int bit, unsigned mode, unsigned long timeout)
{
 do { do { } while (0); } while (0);
 if (!test_bit(bit, word))
  return 0;
 return out_of_line_wait_on_bit_timeout(word, bit,
            bit_wait_timeout,
            mode, timeout);
}
# 1049 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit_action(void *word, int bit, wait_bit_action_f *action, unsigned mode)
{
 do { do { } while (0); } while (0);
 if (!test_bit(bit, word))
  return 0;
 return out_of_line_wait_on_bit(word, bit, action, mode);
}
# 1077 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit_lock(void *word, int bit, unsigned mode)
{
 do { do { } while (0); } while (0);
 if (!_test_and_set_bit(bit,word))
  return 0;
 return out_of_line_wait_on_bit_lock(word, bit, bit_wait, mode);
}
# 1101 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit_lock_io(void *word, int bit, unsigned mode)
{
 do { do { } while (0); } while (0);
 if (!_test_and_set_bit(bit,word))
  return 0;
 return out_of_line_wait_on_bit_lock(word, bit, bit_wait_io, mode);
}
# 1127 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
wait_on_bit_lock_action(void *word, int bit, wait_bit_action_f *action, unsigned mode)
{
 do { do { } while (0); } while (0);
 if (!_test_and_set_bit(bit,word))
  return 0;
 return out_of_line_wait_on_bit_lock(word, bit, action, mode);
}
# 1146 "include/linux/wait.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function))
int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
{
 do { do { } while (0); } while (0);
 if ((*({ __attribute__((unused)) typeof((val)->counter) __var = ( typeof((val)->counter)) 0; (volatile typeof((val)->counter) *)&((val)->counter); })) == 0)
  return 0;
 return out_of_line_wait_on_atomic_t(val, 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/seqlock.h" 1
# 46 "include/linux/seqlock.h"
typedef struct seqcount {
 unsigned sequence;



} seqcount_t;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __seqcount_init(seqcount_t *s, const char *name,
       struct lock_class_key *key)
{



 do { (void)(name); (void)(key); } while (0);
 s->sequence = 0;
}
# 106 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned __read_seqcount_begin(const seqcount_t *s)
{
 unsigned ret;

repeat:
 ret = ({ union { typeof(s->sequence) __val; char __c[1]; } __u; __read_once_size(&(s->sequence), __u.__c, sizeof(s->sequence)); __u.__val; });
 if (__builtin_expect(!!(ret & 1), 0)) {
  __asm__ __volatile__("": : :"memory");
  goto repeat;
 }
 return ret;
}
# 128 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned raw_read_seqcount(const seqcount_t *s)
{
 unsigned ret = ({ union { typeof(s->sequence) __val; char __c[1]; } __u; __read_once_size(&(s->sequence), __u.__c, sizeof(s->sequence)); __u.__val; });
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 return ret;
}
# 144 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned raw_read_seqcount_begin(const seqcount_t *s)
{
 unsigned ret = __read_seqcount_begin(s);
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 return ret;
}
# 160 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned read_seqcount_begin(const seqcount_t *s)
{
 ;
 return raw_read_seqcount_begin(s);
}
# 180 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned raw_seqcount_begin(const seqcount_t *s)
{
 unsigned ret = ({ union { typeof(s->sequence) __val; char __c[1]; } __u; __read_once_size(&(s->sequence), __u.__c, sizeof(s->sequence)); __u.__val; });
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 return ret & ~1;
}
# 201 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __read_seqcount_retry(const seqcount_t *s, unsigned start)
{
 return __builtin_expect(!!(s->sequence != start), 0);
}
# 216 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int read_seqcount_retry(const seqcount_t *s, unsigned start)
{
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 return __read_seqcount_retry(s, start);
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void raw_write_seqcount_begin(seqcount_t *s)
{
 s->sequence++;
 __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void raw_write_seqcount_end(seqcount_t *s)
{
 __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
 s->sequence++;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void raw_write_seqcount_latch(seqcount_t *s)
{
       __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
       s->sequence++;
       __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqcount_begin_nested(seqcount_t *s, int subclass)
{
 raw_write_seqcount_begin(s);
 do { } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqcount_begin(seqcount_t *s)
{
 write_seqcount_begin_nested(s, 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqcount_end(seqcount_t *s)
{
 do { } while (0);
 raw_write_seqcount_end(s);
}
# 275 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqcount_barrier(seqcount_t *s)
{
 __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
 s->sequence+=2;
}

typedef struct {
 struct seqcount seqcount;
 spinlock_t lock;
} seqlock_t;
# 308 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned read_seqbegin(const seqlock_t *sl)
{
 return read_seqcount_begin(&sl->seqcount);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned read_seqretry(const seqlock_t *sl, unsigned start)
{
 return read_seqcount_retry(&sl->seqcount, start);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqlock(seqlock_t *sl)
{
 spin_lock(&sl->lock);
 write_seqcount_begin(&sl->seqcount);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_sequnlock(seqlock_t *sl)
{
 write_seqcount_end(&sl->seqcount);
 spin_unlock(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqlock_bh(seqlock_t *sl)
{
 spin_lock_bh(&sl->lock);
 write_seqcount_begin(&sl->seqcount);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_sequnlock_bh(seqlock_t *sl)
{
 write_seqcount_end(&sl->seqcount);
 spin_unlock_bh(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_seqlock_irq(seqlock_t *sl)
{
 spin_lock_irq(&sl->lock);
 write_seqcount_begin(&sl->seqcount);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void write_sequnlock_irq(seqlock_t *sl)
{
 write_seqcount_end(&sl->seqcount);
 spin_unlock_irq(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __write_seqlock_irqsave(seqlock_t *sl)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&sl->lock)); } while (0); } while (0);
 write_seqcount_begin(&sl->seqcount);
 return flags;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
{
 write_seqcount_end(&sl->seqcount);
 spin_unlock_irqrestore(&sl->lock, flags);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_seqlock_excl(seqlock_t *sl)
{
 spin_lock(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_sequnlock_excl(seqlock_t *sl)
{
 spin_unlock(&sl->lock);
}
# 403 "include/linux/seqlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_seqbegin_or_lock(seqlock_t *lock, int *seq)
{
 if (!(*seq & 1))
  *seq = read_seqbegin(lock);
 else
  read_seqlock_excl(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int need_seqretry(seqlock_t *lock, int seq)
{
 return !(seq & 1) && read_seqretry(lock, seq);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void done_seqretry(seqlock_t *lock, int seq)
{
 if (seq & 1)
  read_sequnlock_excl(lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_seqlock_excl_bh(seqlock_t *sl)
{
 spin_lock_bh(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_sequnlock_excl_bh(seqlock_t *sl)
{
 spin_unlock_bh(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_seqlock_excl_irq(seqlock_t *sl)
{
 spin_lock_irq(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void read_sequnlock_excl_irq(seqlock_t *sl)
{
 spin_unlock_irq(&sl->lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __read_seqlock_excl_irqsave(seqlock_t *sl)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&sl->lock)); } while (0); } while (0);
 return flags;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)
{
 spin_unlock_irqrestore(&sl->lock, flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)
{
 unsigned long flags = 0;

 if (!(*seq & 1))
  *seq = read_seqbegin(lock);
 else
  do { flags = __read_seqlock_excl_irqsave(lock); } while (0);

 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
done_seqretry_irqrestore(seqlock_t *lock, int seq, unsigned long flags)
{
 if (seq & 1)
  read_sequnlock_excl_irqrestore(lock, flags);
}
# 16 "include/linux/mmzone.h" 2
# 1 "include/linux/nodemask.h" 1
# 92 "include/linux/nodemask.h"
# 1 "include/linux/bitmap.h" 1
# 90 "include/linux/bitmap.h"
extern int __bitmap_empty(const unsigned long *bitmap, unsigned int nbits);
extern int __bitmap_full(const unsigned long *bitmap, unsigned int nbits);
extern int __bitmap_equal(const unsigned long *bitmap1,
     const unsigned long *bitmap2, unsigned int nbits);
extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
   unsigned int nbits);
extern void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
    unsigned int shift, unsigned int nbits);
extern void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
    unsigned int shift, unsigned int nbits);
extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, unsigned int nbits);
extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, unsigned int nbits);
extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, unsigned int nbits);
extern int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
   const unsigned long *bitmap2, unsigned int nbits);
extern int __bitmap_intersects(const unsigned long *bitmap1,
   const unsigned long *bitmap2, unsigned int nbits);
extern int __bitmap_subset(const unsigned long *bitmap1,
   const unsigned long *bitmap2, unsigned int nbits);
extern int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);

extern void bitmap_set(unsigned long *map, unsigned int start, int len);
extern void bitmap_clear(unsigned long *map, unsigned int start, int len);

extern unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
          unsigned long size,
          unsigned long start,
          unsigned int nr,
          unsigned long align_mask,
          unsigned long align_offset);
# 136 "include/linux/bitmap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
bitmap_find_next_zero_area(unsigned long *map,
      unsigned long size,
      unsigned long start,
      unsigned int nr,
      unsigned long align_mask)
{
 return bitmap_find_next_zero_area_off(map, size, start, nr,
           align_mask, 0);
}

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_parselist(const char *buf, unsigned long *maskp,
   int nmaskbits);
extern int bitmap_parselist_user(const char *ubuf, unsigned int ulen,
   unsigned long *dst, int nbits);
extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
  const unsigned long *old, const unsigned long *new, unsigned int nbits);
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, unsigned int bits);
extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
  unsigned int sz, unsigned int nbits);
extern int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
extern void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
extern int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);





extern unsigned int bitmap_ord_to_pos(const unsigned long *bitmap, unsigned int ord, unsigned int nbits);
extern int bitmap_print_to_pagebuf(bool list, char *buf,
       const unsigned long *maskp, int nmaskbits);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bitmap_zero(unsigned long *dst, unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  *dst = 0UL;
 else {
  unsigned int len = (((nbits) + (8 * sizeof(long)) - 1) / (8 * sizeof(long))) * sizeof(unsigned long);
  ({ void *__p = (dst); size_t __n = len; if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bitmap_fill(unsigned long *dst, unsigned int nbits)
{
 unsigned int nlongs = (((nbits) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)));
 if (!(__builtin_constant_p(nbits) && (nbits) <= 32)) {
  unsigned int len = (nlongs - 1) * sizeof(unsigned long);
  ({ void *__p = (dst); size_t __n = len; if ((__n) != 0) { if (__builtin_constant_p((0xff)) && (0xff) == 0) __memzero((__p),(__n)); else memset((__p),(0xff),(__n)); } (__p); });
 }
 dst[nlongs - 1] = (~0UL >> (-(nbits) & (32 - 1)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
   unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  *dst = *src;
 else {
  unsigned int len = (((nbits) + (8 * sizeof(long)) - 1) / (8 * sizeof(long))) * sizeof(unsigned long);
  memcpy(dst, src, len);
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bitmap_and(unsigned long *dst, const unsigned long *src1,
   const unsigned long *src2, unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  return (*dst = *src1 & *src2 & (~0UL >> (-(nbits) & (32 - 1)))) != 0;
 return __bitmap_and(dst, src1, src2, nbits);
}

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

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
   const unsigned long *src2, unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  return (*dst = *src1 & ~(*src2) & (~0UL >> (-(nbits) & (32 - 1)))) != 0;
 return __bitmap_andnot(dst, src1, src2, nbits);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
   unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  *dst = ~(*src);
 else
  __bitmap_complement(dst, src, nbits);
}

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

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

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bitmap_empty(const unsigned long *src, unsigned nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  return ! (*src & (~0UL >> (-(nbits) & (32 - 1))));
 else
  return __bitmap_empty(src, nbits);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bitmap_full(const unsigned long *src, unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  return ! (~(*src) & (~0UL >> (-(nbits) & (32 - 1))));
 else
  return __bitmap_full(src, nbits);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bitmap_weight(const unsigned long *src, unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  return hweight_long(*src & (~0UL >> (-(nbits) & (32 - 1))));
 return __bitmap_weight(src, nbits);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bitmap_shift_right(unsigned long *dst, const unsigned long *src,
    unsigned int shift, int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  *dst = (*src & (~0UL >> (-(nbits) & (32 - 1)))) >> shift;
 else
  __bitmap_shift_right(dst, src, shift, nbits);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bitmap_shift_left(unsigned long *dst, const unsigned long *src,
    unsigned int shift, unsigned int nbits)
{
 if ((__builtin_constant_p(nbits) && (nbits) <= 32))
  *dst = (*src << shift) & (~0UL >> (-(nbits) & (32 - 1)));
 else
  __bitmap_shift_left(dst, src, shift, nbits);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bitmap_parse(const char *buf, unsigned int buflen,
   unsigned long *maskp, int nmaskbits)
{
 return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
}
# 93 "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_;
# 116 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void __node_set(int node, volatile nodemask_t *dstp)
{
 _set_bit(node,dstp->bits);
}


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


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


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






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



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



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



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



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



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



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



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



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


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


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


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



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int __first_node(const nodemask_t *srcp)
{
 return ({ int __min1 = ((1 << 0)); int __min2 = (_find_first_bit_le(srcp->bits,(1 << 0))); __min1 < __min2 ? __min1: __min2; });
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __next_node(int n, const nodemask_t *srcp)
{
 return ({ int __min1 = ((1 << 0)); int __min2 = (_find_next_bit_le(srcp->bits,(1 << 0),n+1)); __min1 < __min2 ? __min1: __min2; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_nodemask_of_node(nodemask_t *mask, int node)
{
 __nodes_clear(&(*mask), (1 << 0));
 __node_set((node), &(*mask));
}
# 280 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __first_unset_node(const nodemask_t *maskp)
{
 return ({ int __min1 = ((1 << 0)); int __min2 = (_find_first_zero_bit_le(maskp->bits,(1 << 0))); __min1 < __min2 ? __min1: __min2; })
                                                  ;
}
# 314 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
{
 return bitmap_parselist(buf, dstp->bits, nbits);
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void __nodes_fold(nodemask_t *dstp, const nodemask_t *origp,
  int sz, int nbits)
{
 bitmap_fold(dstp->bits, origp->bits, sz, nbits);
}
# 372 "include/linux/nodemask.h"
enum node_states {
 N_POSSIBLE,
 N_ONLINE,
 N_NORMAL_MEMORY,

 N_HIGH_MEMORY,






 N_MEMORY = N_HIGH_MEMORY,

 N_CPU,
 NR_NODE_STATES
};






extern nodemask_t node_states[NR_NODE_STATES];
# 449 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int node_state(int node, enum node_states state)
{
 return node == 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void node_set_state(int node, enum node_states state)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void node_clear_state(int node, enum node_states state)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int num_node_state(enum node_states state)
{
 return 1;
}
# 484 "include/linux/nodemask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int node_random(const nodemask_t *mask)
{
 return 0;
}
# 516 "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,

 PB_migrate_skip,





 NR_PAGEBLOCK_BITS
};
# 66 "include/linux/pageblock-flags.h"
struct page;

unsigned long get_pfnblock_flags_mask(struct page *page,
    unsigned long pfn,
    unsigned long end_bitidx,
    unsigned long mask);

void set_pfnblock_flags_mask(struct page *page,
    unsigned long flags,
    unsigned long pfn,
    unsigned long end_bitidx,
    unsigned long mask);
# 18 "include/linux/mmzone.h" 2
# 1 "include/linux/page-flags-layout.h" 1




# 1 "include/generated/bounds.h" 1
# 6 "include/linux/page-flags-layout.h" 2
# 19 "include/linux/mmzone.h" 2
# 38 "include/linux/mmzone.h"
enum {
 MIGRATE_UNMOVABLE,
 MIGRATE_RECLAIMABLE,
 MIGRATE_MOVABLE,
 MIGRATE_PCPTYPES,
 MIGRATE_RESERVE = MIGRATE_PCPTYPES,
# 58 "include/linux/mmzone.h"
 MIGRATE_CMA,


 MIGRATE_ISOLATE,

 MIGRATE_TYPES
};
# 76 "include/linux/mmzone.h"
extern int page_group_by_mobility_disabled;
# 85 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_pfnblock_migratetype(struct page *page, unsigned long pfn)
{
 do { bool __cond = !(!(PB_migrate_end - PB_migrate != 2)); extern void __compiletime_assert_87(void) __attribute__((error("BUILD_BUG_ON failed: " "PB_migrate_end - PB_migrate != 2"))); if (__cond) __compiletime_assert_87(); do { } while (0); } while (0);
 return get_pfnblock_flags_mask(page, pfn, PB_migrate_end,
     ((1UL << (PB_migrate_end - PB_migrate + 1)) - 1));
}

struct free_area {
 struct list_head free_list[MIGRATE_TYPES];
 unsigned long nr_free;
};

struct pglist_data;
# 106 "include/linux/mmzone.h"
struct zone_padding {
 char x[0];
} __attribute__((__aligned__(1 << (6))));





enum zone_stat_item {

 NR_FREE_PAGES,
 NR_ALLOC_BATCH,
 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_VMSCAN_IMMEDIATE,
 NR_WRITEBACK_TEMP,
 NR_ISOLATED_ANON,
 NR_ISOLATED_FILE,
 NR_SHMEM,
 NR_DIRTIED,
 NR_WRITTEN,
 NR_PAGES_SCANNED,
# 155 "include/linux/mmzone.h"
 WORKINGSET_REFAULT,
 WORKINGSET_ACTIVATE,
 WORKINGSET_NODERECLAIM,
 NR_ANON_TRANSPARENT_HUGEPAGES,
 NR_FREE_CMA_PAGES,
 NR_VM_ZONE_STAT_ITEMS };
# 175 "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)) __attribute__((no_instrument_function)) int is_file_lru(enum lru_list lru)
{
 return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_active_lru(enum lru_list lru)
{
 return (lru == LRU_ACTIVE_ANON || lru == LRU_ACTIVE_FILE);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_unevictable_lru(enum lru_list lru)
{
 return (lru == LRU_UNEVICTABLE);
}

struct zone_reclaim_stat {
# 212 "include/linux/mmzone.h"
 unsigned long recent_rotated[2];
 unsigned long recent_scanned[2];
};

struct lruvec {
 struct list_head lists[NR_LRU_LISTS];
 struct zone_reclaim_stat reclaim_stat;



};
# 239 "include/linux/mmzone.h"
typedef unsigned isolate_mode_t;

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[MIGRATE_PCPTYPES];
};

struct per_cpu_pageset {
 struct per_cpu_pages pcp;




 s8 stat_threshold;
 s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];

};



enum zone_type {
# 309 "include/linux/mmzone.h"
 ZONE_NORMAL,
# 319 "include/linux/mmzone.h"
 ZONE_HIGHMEM,

 ZONE_MOVABLE,
 __MAX_NR_ZONES
};



struct zone {



 unsigned long watermark[NR_WMARK];
# 341 "include/linux/mmzone.h"
 long lowmem_reserve[3];
# 351 "include/linux/mmzone.h"
 unsigned int inactive_ratio;

 struct pglist_data *zone_pgdat;
 struct per_cpu_pageset *pageset;





 unsigned long dirty_balance_reserve;






 unsigned long *pageblock_flags;
# 379 "include/linux/mmzone.h"
 unsigned long zone_start_pfn;
# 422 "include/linux/mmzone.h"
 unsigned long managed_pages;
 unsigned long spanned_pages;
 unsigned long present_pages;

 const char *name;





 int nr_migrate_reserve_block;







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

 struct zone_padding _pad1_;


 spinlock_t lock;


 struct free_area free_area[11];


 unsigned long flags;

 struct zone_padding _pad2_;




 spinlock_t lru_lock;
 struct lruvec lruvec;


 atomic_long_t inactive_age;






 unsigned long percpu_drift_mark;



 unsigned long compact_cached_free_pfn;

 unsigned long compact_cached_migrate_pfn[2];
# 518 "include/linux/mmzone.h"
 unsigned int compact_considered;
 unsigned int compact_defer_shift;
 int compact_order_failed;




 bool compact_blockskip_flush;


 struct zone_padding _pad3_;

 atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
} __attribute__((__aligned__(1 << (6))));

enum zone_flags {
 ZONE_RECLAIM_LOCKED,
 ZONE_OOM_LOCKED,
 ZONE_CONGESTED,


 ZONE_DIRTY,



 ZONE_WRITEBACK,


 ZONE_FAIR_DEPLETED,
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long zone_end_pfn(const struct zone *zone)
{
 return zone->zone_start_pfn + zone->spanned_pages;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool zone_spans_pfn(const struct zone *zone, unsigned long pfn)
{
 return zone->zone_start_pfn <= pfn && pfn < zone_end_pfn(zone);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool zone_is_initialized(struct zone *zone)
{
 return !!zone->wait_table;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool zone_is_empty(struct zone *zone)
{
 return zone->spanned_pages == 0;
}
# 657 "include/linux/mmzone.h"
struct zonelist_cache;






struct zoneref {
 struct zone *zone;
 int zone_idx;
};
# 686 "include/linux/mmzone.h"
struct zonelist {
 struct zonelist_cache *zlcache_ptr;
 struct zoneref _zonerefs[((1 << 0) * 3) + 1];



};
# 704 "include/linux/mmzone.h"
extern struct page *mem_map;
# 718 "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;
# 745 "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;
 wait_queue_head_t pfmemalloc_wait;
 struct task_struct *kswapd;

 int kswapd_max_order;
 enum zone_type classzone_idx;
# 766 "include/linux/mmzone.h"
} pg_data_t;
# 780 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long pgdat_end_pfn(pg_data_t *pgdat)
{
 return pgdat->node_start_pfn + pgdat->node_spanned_pages;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool pgdat_is_empty(pg_data_t *pgdat)
{
 return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
}

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



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

# 1 "include/linux/notifier.h" 1
# 13 "include/linux/notifier.h"
# 1 "include/linux/mutex.h" 1
# 13 "include/linux/mutex.h"
# 1 "arch/arm/include/generated/asm/current.h" 1
# 14 "include/linux/mutex.h" 2






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







struct optimistic_spin_node {
 struct optimistic_spin_node *next, *prev;
 int locked;
 int cpu;
};

struct optimistic_spin_queue {




 atomic_t tail;
};






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void osq_lock_init(struct optimistic_spin_queue *lock)
{
 (((&lock->tail)->counter) = ((0)));
}

extern bool osq_lock(struct optimistic_spin_queue *lock);
extern void osq_unlock(struct optimistic_spin_queue *lock);
# 21 "include/linux/mutex.h" 2
# 50 "include/linux/mutex.h"
struct mutex {

 atomic_t count;
 spinlock_t wait_lock;
 struct list_head wait_list;

 struct task_struct *owner;





 void *magic;




};





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

 void *magic;

};


# 1 "include/linux/mutex-debug.h" 1





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







struct task_struct;

extern int debug_locks;
extern int debug_locks_silent;


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __debug_locks_off(void)
{
 return ((__typeof__(*(&debug_locks)))__xchg((unsigned long)(0),(&debug_locks),sizeof(*(&debug_locks))));
}




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







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

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

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_check_no_locks_held(void)
{
}
# 7 "include/linux/mutex-debug.h" 2
# 22 "include/linux/mutex-debug.h"
extern void mutex_destroy(struct mutex *lock);
# 83 "include/linux/mutex.h" 2
# 119 "include/linux/mutex.h"
extern void __mutex_init(struct mutex *lock, const char *name,
    struct lock_class_key *key);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mutex_is_locked(struct mutex *lock)
{
 return (*({ __attribute__((unused)) typeof((&lock->count)->counter) __var = ( typeof((&lock->count)->counter)) 0; (volatile typeof((&lock->count)->counter) *)&((&lock->count)->counter); })) != 1;
}
# 157 "include/linux/mutex.h"
extern void mutex_lock(struct mutex *lock);
extern int __attribute__((warn_unused_result)) mutex_lock_interruptible(struct mutex *lock);
extern int __attribute__((warn_unused_result)) mutex_lock_killable(struct mutex *lock);
# 173 "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
# 21 "include/linux/rwsem.h"
struct rw_semaphore;





struct rw_semaphore {
 long count;
 struct list_head wait_list;
 raw_spinlock_t wait_lock;

 struct optimistic_spin_queue osq;




 struct task_struct *owner;




};

extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_down_write_failed(struct rw_semaphore *sem);
extern struct rw_semaphore *rwsem_wake(struct rw_semaphore *);
extern struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem);


# 1 "arch/arm/include/generated/asm/rwsem.h" 1
# 1 "include/asm-generic/rwsem.h" 1
# 34 "include/asm-generic/rwsem.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __down_read(struct rw_semaphore *sem)
{
 if (__builtin_expect(!!(atomic_long_inc_return((atomic_long_t *)&sem->count) <= 0), 0))
  rwsem_down_read_failed(sem);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __down_read_trylock(struct rw_semaphore *sem)
{
 long tmp;

 while ((tmp = sem->count) >= 0) {
  if (tmp == ((__typeof__(*(&sem->count)))__cmpxchg_mb((&sem->count), (unsigned long)(tmp), (unsigned long)(tmp + 0x00000001L), sizeof(*(&sem->count))))
                                    ) {
   return 1;
  }
 }
 return 0;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __down_write_nested(struct rw_semaphore *sem, int subclass)
{
 long tmp;

 tmp = atomic_long_add_return(((-0x0000ffffL -1) + 0x00000001L),
         (atomic_long_t *)&sem->count);
 if (__builtin_expect(!!(tmp != ((-0x0000ffffL -1) + 0x00000001L)), 0))
  rwsem_down_write_failed(sem);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __down_write(struct rw_semaphore *sem)
{
 __down_write_nested(sem, 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __down_write_trylock(struct rw_semaphore *sem)
{
 long tmp;

 tmp = ((__typeof__(*(&sem->count)))__cmpxchg_mb((&sem->count), (unsigned long)(0x00000000L), (unsigned long)(((-0x0000ffffL -1) + 0x00000001L)), sizeof(*(&sem->count))))
                                ;
 return tmp == 0x00000000L;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __up_read(struct rw_semaphore *sem)
{
 long tmp;

 tmp = atomic_long_dec_return((atomic_long_t *)&sem->count);
 if (__builtin_expect(!!(tmp < -1 && (tmp & 0x0000ffffL) == 0), 0))
  rwsem_wake(sem);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __up_write(struct rw_semaphore *sem)
{
 if (__builtin_expect(!!(atomic_long_sub_return(((-0x0000ffffL -1) + 0x00000001L), (atomic_long_t *)&sem->count) < 0), 0)
                                       )
  rwsem_wake(sem);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rwsem_atomic_add(long delta, struct rw_semaphore *sem)
{
 atomic_long_add(delta, (atomic_long_t *)&sem->count);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __downgrade_write(struct rw_semaphore *sem)
{
 long tmp;

 tmp = atomic_long_add_return(-(-0x0000ffffL -1),
         (atomic_long_t *)&sem->count);
 if (tmp < 0)
  rwsem_downgrade_wake(sem);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long rwsem_atomic_update(long delta, struct rw_semaphore *sem)
{
 return atomic_long_add_return(delta, (atomic_long_t *)&sem->count);
}
# 1 "arch/arm/include/generated/asm/rwsem.h" 2
# 51 "include/linux/rwsem.h" 2


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int rwsem_is_locked(struct rw_semaphore *sem)
{
 return sem->count != 0;
}
# 84 "include/linux/rwsem.h"
extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
    struct lock_class_key *key);
# 100 "include/linux/rwsem.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int rwsem_is_contended(struct rw_semaphore *sem)
{
 return !list_empty(&sem->wait_list);
}




extern void down_read(struct rw_semaphore *sem);




extern int down_read_trylock(struct rw_semaphore *sem);




extern void down_write(struct rw_semaphore *sem);




extern int down_write_trylock(struct rw_semaphore *sem);




extern void up_read(struct rw_semaphore *sem);




extern void up_write(struct rw_semaphore *sem);




extern void downgrade_write(struct rw_semaphore *sem);
# 15 "include/linux/notifier.h" 2
# 1 "include/linux/srcu.h" 1
# 33 "include/linux/srcu.h"
# 1 "include/linux/rcupdate.h" 1
# 40 "include/linux/rcupdate.h"
# 1 "include/linux/cpumask.h" 1
# 14 "include/linux/cpumask.h"
typedef struct cpumask { unsigned long bits[(((8) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))]; } cpumask_t;
# 36 "include/linux/cpumask.h"
extern int nr_cpu_ids;
# 87 "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;
# 113 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int cpumask_check(unsigned int cpu)
{



 return cpu;
}
# 173 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int cpumask_first(const struct cpumask *srcp)
{
 return _find_first_bit_le(((srcp)->bits),8);
}
# 185 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int cpumask_next(int n, const struct cpumask *srcp)
{

 if (n != -1)
  cpumask_check(n);
 return _find_next_bit_le(((srcp)->bits),8,n+1);
}
# 200 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
{

 if (n != -1)
  cpumask_check(n);
 return _find_next_zero_bit_le(((srcp)->bits),8,n+1);
}

int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
int cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
int cpumask_set_cpu_local_first(int i, int numa_node, cpumask_t *dstp);
# 271 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
{
 _set_bit(cpumask_check(cpu),((dstp)->bits));
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_clear_cpu(int cpu, struct cpumask *dstp)
{
 _clear_bit(cpumask_check(cpu),((dstp)->bits));
}
# 307 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)
{
 return _test_and_set_bit(cpumask_check(cpu),((cpumask)->bits));
}
# 321 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void cpumask_setall(struct cpumask *dstp)
{
 bitmap_fill(((dstp)->bits), 8);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_clear(struct cpumask *dstp)
{
 bitmap_zero(((dstp)->bits), 8);
}
# 352 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_and(struct cpumask *dstp,
          const struct cpumask *src1p,
          const struct cpumask *src2p)
{
 return bitmap_and(((dstp)->bits), ((src1p)->bits),
           ((src2p)->bits), 8);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,
         const struct cpumask *src2p)
{
 bitmap_or(((dstp)->bits), ((src1p)->bits),
          ((src2p)->bits), 8);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_xor(struct cpumask *dstp,
          const struct cpumask *src1p,
          const struct cpumask *src2p)
{
 bitmap_xor(((dstp)->bits), ((src1p)->bits),
           ((src2p)->bits), 8);
}
# 395 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_andnot(struct cpumask *dstp,
      const struct cpumask *src1p,
      const struct cpumask *src2p)
{
 return bitmap_andnot(((dstp)->bits), ((src1p)->bits),
       ((src2p)->bits), 8);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_complement(struct cpumask *dstp,
          const struct cpumask *srcp)
{
 bitmap_complement(((dstp)->bits), ((srcp)->bits),
           8);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cpumask_equal(const struct cpumask *src1p,
    const struct cpumask *src2p)
{
 return bitmap_equal(((src1p)->bits), ((src2p)->bits),
       8);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cpumask_intersects(const struct cpumask *src1p,
         const struct cpumask *src2p)
{
 return bitmap_intersects(((src1p)->bits), ((src2p)->bits),
            8);
}
# 446 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_subset(const struct cpumask *src1p,
     const struct cpumask *src2p)
{
 return bitmap_subset(((src1p)->bits), ((src2p)->bits),
        8);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cpumask_empty(const struct cpumask *srcp)
{
 return bitmap_empty(((srcp)->bits), 8);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cpumask_full(const struct cpumask *srcp)
{
 return bitmap_full(((srcp)->bits), 8);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int cpumask_weight(const struct cpumask *srcp)
{
 return bitmap_weight(((srcp)->bits), 8);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_shift_right(struct cpumask *dstp,
           const struct cpumask *srcp, int n)
{
 bitmap_shift_right(((dstp)->bits), ((srcp)->bits), n,
            8);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_shift_left(struct cpumask *dstp,
          const struct cpumask *srcp, int n)
{
 bitmap_shift_left(((dstp)->bits), ((srcp)->bits), n,
           8);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cpumask_copy(struct cpumask *dstp,
    const struct cpumask *srcp)
{
 bitmap_copy(((dstp)->bits), ((srcp)->bits), 8);
}
# 557 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_parse_user(const char *buf, int len,
         struct cpumask *dstp)
{
 return bitmap_parse_user(buf, len, ((dstp)->bits), nr_cpu_ids);
}
# 571 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_parselist_user(const char *buf, int len,
         struct cpumask *dstp)
{
 return bitmap_parselist_user(buf, len, ((dstp)->bits),
         nr_cpu_ids);
}
# 585 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpumask_parse(const char *buf, struct cpumask *dstp)
{
 char *nl = strchr(buf, '\n');
 unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf);

 return bitmap_parse(buf, len, ((dstp)->bits), nr_cpu_ids);
}
# 600 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpulist_parse(const char *buf, struct cpumask *dstp)
{
 return bitmap_parselist(buf, ((dstp)->bits), nr_cpu_ids);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) size_t cpumask_size(void)
{


 return (((8) + (8 * sizeof(long)) - 1) / (8 * sizeof(long))) * sizeof(long);
}
# 668 "include/linux/cpumask.h"
typedef struct cpumask cpumask_var_t[1];



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,
       int node)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
{
 cpumask_clear(*mask);
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,
       int node)
{
 cpumask_clear(*mask);
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void alloc_bootmem_cpumask_var(cpumask_var_t *mask)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void free_cpumask_var(cpumask_var_t mask)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void free_bootmem_cpumask_var(cpumask_var_t mask)
{
}




extern const unsigned long cpu_all_bits[(((8) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];
# 722 "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);
# 744 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __check_is_bitmap(const unsigned long *bitmap)
{
 return 1;
}
# 756 "include/linux/cpumask.h"
extern const unsigned long
 cpu_bit_bitmap[32 +1][(((8) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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))));
}
# 793 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ssize_t
cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask)
{
 return bitmap_print_to_pagebuf(list, buf, ((mask)->bits),
          nr_cpu_ids);
}
# 844 "include/linux/cpumask.h"
int __first_cpu(const cpumask_t *srcp);
int __next_cpu(int n, const cpumask_t *srcp);
# 873 "include/linux/cpumask.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __cpu_set(int cpu, volatile cpumask_t *dstp)
{
 _set_bit(cpu,dstp->bits);
}


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


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


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





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


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


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


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



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


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


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


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


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


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



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __cpus_shift_left(cpumask_t *dstp,
     const cpumask_t *srcp, int n, int nbits)
{
 bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
}
# 41 "include/linux/rcupdate.h" 2


# 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)) __attribute__((no_instrument_function)) void init_completion(struct completion *x)
{
 x->done = 0;
 do { static struct lock_class_key __key; __init_waitqueue_head((&x->wait), "&x->wait", &__key); } while (0);
}
# 86 "include/linux/completion.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void reinit_completion(struct completion *x)
{
 x->done = 0;
}

extern void wait_for_completion(struct completion *);
extern void wait_for_completion_io(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_io_timeout(struct completion *x,
          unsigned long timeout);
extern long wait_for_completion_interruptible_timeout(
 struct completion *x, unsigned long timeout);
extern long wait_for_completion_killable_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 *);
# 44 "include/linux/rcupdate.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;
# 27 "include/linux/debugobjects.h"
struct debug_obj {
 struct hlist_node node;
 enum debug_obj_state state;
 unsigned int astate;
 void *object;
 struct debug_obj_descr *descr;
};
# 52 "include/linux/debugobjects.h"
struct debug_obj_descr {
 const char *name;
 void *(*debug_hint) (void *addr);
 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);
 int (*fixup_assert_init)(void *addr, enum debug_obj_state state);
};
# 84 "include/linux/debugobjects.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_object_init (void *addr, struct debug_obj_descr *descr) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
debug_object_activate (void *addr, struct debug_obj_descr *descr) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_object_deactivate(void *addr, struct debug_obj_descr *descr) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_object_destroy (void *addr, struct debug_obj_descr *descr) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_object_free (void *addr, struct debug_obj_descr *descr) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_object_assert_init(void *addr, struct debug_obj_descr *descr) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void debug_objects_early_init(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void debug_objects_mem_init(void) { }





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
debug_check_no_obj_freed(const void *address, unsigned long size) { }
# 45 "include/linux/rcupdate.h" 2




extern int rcu_expedited;
# 66 "include/linux/rcupdate.h"
bool rcu_gp_is_expedited(void);
void rcu_expedite_gp(void);
void rcu_unexpedite_gp(void);


enum rcutorture_type {
 RCU_FLAVOR,
 RCU_BH_FLAVOR,
 RCU_SCHED_FLAVOR,
 RCU_TASKS_FLAVOR,
 SRCU_FLAVOR,
 INVALID_RCU_FLAVOR
};


void rcutorture_get_gp_data(enum rcutorture_type test_type, int *flags,
       unsigned long *gpnum, unsigned long *completed);
void rcutorture_record_test_transition(void);
void rcutorture_record_progress(unsigned long vernum);
void do_trace_rcu_torture_read(const char *rcutorturename,
          struct callback_head *rhp,
          unsigned long secs,
          unsigned long c_old,
          unsigned long c);
# 160 "include/linux/rcupdate.h"
void call_rcu(struct callback_head *head,
       void (*func)(struct callback_head *head));
# 191 "include/linux/rcupdate.h"
void call_rcu_bh(struct callback_head *head,
   void (*func)(struct callback_head *head));
# 213 "include/linux/rcupdate.h"
void call_rcu_sched(struct callback_head *head,
      void (*func)(struct callback_head *rcu));

void synchronize_sched(void);




struct rcu_synchronize {
 struct callback_head head;
 struct completion completion;
};
void wakeme_after_rcu(struct callback_head *head);
# 245 "include/linux/rcupdate.h"
void call_rcu_tasks(struct callback_head *head, void (*func)(struct callback_head *head));
void synchronize_rcu_tasks(void);
void rcu_barrier_tasks(void);



void __rcu_read_lock(void);
void __rcu_read_unlock(void);
void rcu_read_unlock_special(struct task_struct *t);
void synchronize_rcu(void);
# 289 "include/linux/rcupdate.h"
void rcu_init(void);
void rcu_end_inkernel_boot(void);
void rcu_sched_qs(void);
void rcu_bh_qs(void);
void rcu_check_callbacks(int user);
struct notifier_block;
void rcu_idle_enter(void);
void rcu_idle_exit(void);
void rcu_irq_enter(void);
void rcu_irq_exit(void);
int rcu_cpu_notify(struct notifier_block *self,
     unsigned long action, void *hcpu);


void rcu_sysrq_start(void);
void rcu_sysrq_end(void);
# 318 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_user_enter(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_user_exit(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_user_hooks_switch(struct task_struct *prev,
      struct task_struct *next) { }





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_init_nohz(void)
{
}
# 389 "include/linux/rcupdate.h"
bool __rcu_is_watching(void);







typedef void call_rcu_func_t(struct callback_head *head,
        void (*func)(struct callback_head *head));
void wait_rcu_gp(call_rcu_func_t crf);


# 1 "include/linux/rcutree.h" 1
# 33 "include/linux/rcutree.h"
void rcu_note_context_switch(void);
int rcu_needs_cpu(unsigned long *delta_jiffies);
void rcu_cpu_stall_reset(void);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_virt_note_context_switch(int cpu)
{
 rcu_note_context_switch();
}

void synchronize_rcu_bh(void);
void synchronize_sched_expedited(void);
void synchronize_rcu_expedited(void);

void kfree_call_rcu(struct callback_head *head, void (*func)(struct callback_head *rcu));
# 69 "include/linux/rcutree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void synchronize_rcu_bh_expedited(void)
{
 synchronize_sched_expedited();
}

void rcu_barrier(void);
void rcu_barrier_bh(void);
void rcu_barrier_sched(void);
unsigned long get_state_synchronize_rcu(void);
void cond_synchronize_rcu(unsigned long oldstate);

extern unsigned long rcutorture_testseq;
extern unsigned long rcutorture_vernum;
unsigned long rcu_batches_started(void);
unsigned long rcu_batches_started_bh(void);
unsigned long rcu_batches_started_sched(void);
unsigned long rcu_batches_completed(void);
unsigned long rcu_batches_completed_bh(void);
unsigned long rcu_batches_completed_sched(void);
void show_rcu_gp_kthreads(void);

void rcu_force_quiescent_state(void);
void rcu_bh_force_quiescent_state(void);
void rcu_sched_force_quiescent_state(void);

void exit_rcu(void);

void rcu_scheduler_starting(void);
extern int rcu_scheduler_active __attribute__((__section__(".data..read_mostly")));

bool rcu_is_watching(void);

void rcu_all_qs(void);
# 403 "include/linux/rcupdate.h" 2
# 421 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_rcu_head(struct callback_head *head)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void destroy_rcu_head(struct callback_head *head)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_rcu_head_on_stack(struct callback_head *head)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void destroy_rcu_head_on_stack(struct callback_head *head)
{
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool rcu_lockdep_current_cpu_online(void)
{
 return true;
}
# 526 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int rcu_read_lock_held(void)
{
 return 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int rcu_read_lock_bh_held(void)
{
 return 1;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int rcu_read_lock_sched_held(void)
{
 return preempt_count() != 0 || ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); });
}
# 910 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_lock(void)
{
 __rcu_read_lock();
 (void)0;
 do { } while (0);
 do { } while (0)
                                                  ;
}
# 964 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_unlock(void)
{
 do { } while (0)
                                                    ;
 (void)0;
 __rcu_read_unlock();
 do { } while (0);
}
# 990 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_lock_bh(void)
{
 local_bh_disable();
 (void)0;
 do { } while (0);
 do { } while (0)
                                                     ;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_unlock_bh(void)
{
 do { } while (0)
                                                       ;
 do { } while (0);
 (void)0;
 local_bh_enable();
}
# 1026 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_lock_sched(void)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 (void)0;
 do { } while (0);
 do { } while (0)
                                                        ;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void rcu_read_lock_sched_notrace(void)
{
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 (void)0;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_read_unlock_sched(void)
{
 do { } while (0)
                                                          ;
 do { } while (0);
 (void)0;
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void rcu_read_unlock_sched_notrace(void)
{
 (void)0;
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) preempt_schedule(); } while (0);
}
# 1169 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool rcu_is_nocb_cpu(int cpu) { return false; }
# 1179 "include/linux/rcupdate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool rcu_sys_is_idle(void)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_sysidle_force_exit(void)
{
}
# 34 "include/linux/srcu.h" 2
# 1 "include/linux/workqueue.h" 1







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




# 1 "include/linux/ktime.h" 1
# 24 "include/linux/ktime.h"
# 1 "include/linux/time.h" 1





# 1 "include/linux/math64.h" 1
# 64 "include/linux/math64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
{
 *remainder = ({ unsigned int __r, __b = (divisor); if (!__builtin_constant_p(__b) || __b == 0 || (7 < 4 && (__b & (__b - 1)) != 0)) { __r = ({ register unsigned int __base asm("r4") = __b; register unsigned long long __n asm("r0") = dividend; register unsigned long long __res asm("r2"); register unsigned int __rem asm("r1"); asm( ".ifnc " "%0" "," "r1" "; " ".ifnc " "%0" "r1" ",fpr11; " ".ifnc " "%0" "r1" ",r11fp; " ".ifnc " "%0" "r1" ",ipr12; " ".ifnc " "%0" "r1" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" ".ifnc " "%1" "," "r2" "; " ".ifnc " "%1" "r2" ",fpr11; " ".ifnc " "%1" "r2" ",r11fp; " ".ifnc " "%1" "r2" ",ipr12; " ".ifnc " "%1" "r2" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" ".ifnc " "%2" "," "r0" "; " ".ifnc " "%2" "r0" ",fpr11; " ".ifnc " "%2" "r0" ",r11fp; " ".ifnc " "%2" "r0" ",ipr12; " ".ifnc " "%2" "r0" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" ".ifnc " "%3" "," "r4" "; " ".ifnc " "%3" "r4" ",fpr11; " ".ifnc " "%3" "r4" ",r11fp; " ".ifnc " "%3" "r4" ",ipr12; " ".ifnc " "%3" "r4" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" "bl	__do_div64" : "=r" (__rem), "=r" (__res) : "r" (__n), "r" (__base) : "ip", "lr", "cc"); dividend = __res; __rem; }); } else if ((__b & (__b - 1)) == 0) { __r = dividend; __r &= (__b - 1); dividend /= __b; } else { unsigned long long __res, __x, __t, __m, __n = dividend; unsigned int __c, __p, __z = 0; __r = __n; __p = 1 << ({ unsigned int __left = (__b), __nr = 0; if (__left & 0xffff0000) __nr += 16, __left >>= 16; if (__left & 0x0000ff00) __nr += 8, __left >>= 8; if (__left & 0x000000f0) __nr += 4, __left >>= 4; if (__left & 0x0000000c) __nr += 2, __left >>= 2; if (__left & 0x00000002) __nr += 1; __nr; }); __m = (~0ULL / __b) * __p; __m += (((~0ULL % __b + 1) * __p) + __b - 1) / __b; __x = ~0ULL / __b * __b - 1; __res = (__m & 0xffffffff) * (__x & 0xffffffff); __res >>= 32; __res += (__m & 0xffffffff) * (__x >> 32); __t = __res; __res += (__x & 0xffffffff) * (__m >> 32); __t = (__res < __t) ? (1ULL << 32) : 0; __res = (__res >> 32) + __t; __res += (__m >> 32) * (__x >> 32); __res /= __p; if (~0ULL % (__b / (__b & -__b)) == 0) { __n /= (__b & -__b); __m = ~0ULL / (__b / (__b & -__b)); __p = 1; __c = 1; } else if (__res != __x / __b) { __c = 1; __m = (~0ULL / __b) * __p; __m += ((~0ULL % __b + 1) * __p) / __b; } else { unsigned int __bits = -(__m & -__m); __bits |= __m >> 32; __bits = (~__bits) << 1; if (!__bits) { __p /= (__m & -__m); __m /= (__m & -__m); } else { __p >>= ({ unsigned int __left = (__bits), __nr = 0; if (__left & 0xffff0000) __nr += 16, __left >>= 16; if (__left & 0x0000ff00) __nr += 8, __left >>= 8; if (__left & 0x000000f0) __nr += 4, __left >>= 4; if (__left & 0x0000000c) __nr += 2, __left >>= 2; if (__left & 0x00000002) __nr += 1; __nr; }); __m >>= ({ unsigned int __left = (__bits), __nr = 0; if (__left & 0xffff0000) __nr += 16, __left >>= 16; if (__left & 0x0000ff00) __nr += 8, __left >>= 8; if (__left & 0x000000f0) __nr += 4, __left >>= 4; if (__left & 0x0000000c) __nr += 2, __left >>= 2; if (__left & 0x00000002) __nr += 1; __nr; }); } __c = 0; } if (!__c) { asm ( "umull	%Q0, %R0, %Q1, %Q2\n\t" "mov	%Q0, #0" : "=&r" (__res) : "r" (__m), "r" (__n) : "cc" ); } else if (!(__m & ((1ULL << 63) | (1ULL << 31)))) { __res = __m; asm ( "umlal	%Q0, %R0, %Q1, %Q2\n\t" "mov	%Q0, #0" : "+&r" (__res) : "r" (__m), "r" (__n) : "cc" ); } else { asm ( "umull	%Q0, %R0, %Q1, %Q2\n\t" "cmn	%Q0, %Q1\n\t" "adcs	%R0, %R0, %R1\n\t" "adc	%Q0, %3, #0" : "=&r" (__res) : "r" (__m), "r" (__n), "r" (__z) : "cc" ); } if (!(__m & ((1ULL << 63) | (1ULL << 31)))) { asm ( "umlal	%R0, %Q0, %R1, %Q2\n\t" "umlal	%R0, %Q0, %Q1, %R2\n\t" "mov	%R0, #0\n\t" "umlal	%Q0, %R0, %R1, %R2" : "+&r" (__res) : "r" (__m), "r" (__n) : "cc" ); } else { asm ( "umlal	%R0, %Q0, %R2, %Q3\n\t" "umlal	%R0, %1, %Q2, %R3\n\t" "mov	%R0, #0\n\t" "adds	%Q0, %1, %Q0\n\t" "adc	%R0, %R0, #0\n\t" "umlal	%Q0, %R0, %R2, %R3" : "+&r" (__res), "+&r" (__z) : "r" (__m), "r" (__n) : "cc" ); } __res /= __p; { unsigned int __res0 = __res; unsigned int __b0 = __b; __r -= __res0 * __b0; } dividend = __res; } __r; });
 return dividend;
}



extern s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder);



extern u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder);



extern u64 div64_u64(u64 dividend, u64 divisor);



extern s64 div64_s64(s64 dividend, s64 divisor);
# 97 "include/linux/math64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 div_u64(u64 dividend, u32 divisor)
{
 u32 remainder;
 return div_u64_rem(dividend, divisor, &remainder);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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__((no_instrument_function)) __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;
}
# 148 "include/linux/math64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 mul_u64_u32_shr(u64 a, u32 mul, unsigned int shift)
{
 u32 ah, al;
 u64 ret;

 al = a;
 ah = a >> 32;

 ret = ((u64)al * mul) >> shift;
 if (ah)
  ret += ((u64)ah * mul) << (32 - shift);

 return ret;
}
# 7 "include/linux/time.h" 2
# 1 "include/linux/time64.h" 1



# 1 "include/uapi/linux/time.h" 1
# 9 "include/uapi/linux/time.h"
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;
};
# 34 "include/uapi/linux/time.h"
struct itimerspec {
 struct timespec it_interval;
 struct timespec it_value;
};

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

typedef __s64 time64_t;
# 15 "include/linux/time64.h"
struct timespec64 {
 time64_t tv_sec;
 long tv_nsec;
};
# 60 "include/linux/time64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct timespec timespec64_to_timespec(const struct timespec64 ts64)
{
 struct timespec ret;

 ret.tv_sec = (time_t)ts64.tv_sec;
 ret.tv_nsec = ts64.tv_nsec;
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct timespec64 timespec_to_timespec64(const struct timespec ts)
{
 struct timespec64 ret;

 ret.tv_sec = ts.tv_sec;
 ret.tv_nsec = ts.tv_nsec;
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int timespec64_equal(const struct timespec64 *a,
       const struct timespec64 *b)
{
 return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int timespec64_compare(const struct timespec64 *lhs, const struct timespec64 *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;
}

extern void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);






extern struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
      const struct timespec64 rhs);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct timespec64 timespec64_add(struct timespec64 lhs,
      struct timespec64 rhs)
{
 struct timespec64 ts_delta;
 set_normalized_timespec64(&ts_delta, lhs.tv_sec + rhs.tv_sec,
    lhs.tv_nsec + rhs.tv_nsec);
 return ts_delta;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct timespec64 timespec64_sub(struct timespec64 lhs,
      struct timespec64 rhs)
{
 struct timespec64 ts_delta;
 set_normalized_timespec64(&ts_delta, lhs.tv_sec - rhs.tv_sec,
    lhs.tv_nsec - rhs.tv_nsec);
 return ts_delta;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool timespec64_valid(const struct timespec64 *ts)
{

 if (ts->tv_sec < 0)
  return false;

 if ((unsigned long)ts->tv_nsec >= 1000000000L)
  return false;
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool timespec64_valid_strict(const struct timespec64 *ts)
{
 if (!timespec64_valid(ts))
  return false;

 if ((unsigned long long)ts->tv_sec >= (((s64)~((u64)1 << 63)) / 1000000000L))
  return false;
 return true;
}
# 161 "include/linux/time64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 timespec64_to_ns(const struct timespec64 *ts)
{
 return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;
}







extern struct timespec64 ns_to_timespec64(const s64 nsec);
# 182 "include/linux/time64.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void timespec64_add_ns(struct timespec64 *a, u64 ns)
{
 a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, 1000000000L, &ns);
 a->tv_nsec = ns;
}
# 8 "include/linux/time.h" 2

extern struct timezone sys_tz;



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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 time64_t mktime64(const unsigned int year, const unsigned int mon,
   const unsigned int day, const unsigned int hour,
   const unsigned int min, const unsigned int sec);




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)
{
 return mktime64(year, mon, day, hour, min, 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)) __attribute__((no_instrument_function)) struct timespec timespec_add(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;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool timespec_valid(const struct timespec *ts)
{

 if (ts->tv_sec < 0)
  return false;

 if ((unsigned long)ts->tv_nsec >= 1000000000L)
  return false;
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool timespec_valid_strict(const struct timespec *ts)
{
 if (!timespec_valid(ts))
  return false;

 if ((unsigned long long)ts->tv_sec >= (((s64)~((u64)1 << 63)) / 1000000000L))
  return false;
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool timeval_valid(const struct timeval *tv)
{

 if (tv->tv_sec < 0)
  return false;


 if (tv->tv_usec < 0 || tv->tv_usec >= 1000000L)
  return false;

 return true;
}

extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
# 144 "include/linux/time.h"
struct itimerval;
extern int do_setitimer(int which, struct itimerval *value,
   struct itimerval *ovalue);
extern int do_getitimer(int which, struct itimerval *value);

extern unsigned int alarm_setitimer(unsigned int seconds);

extern long do_utimes(int dfd, const char *filename, struct timespec *times, int flags);

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);
# 191 "include/linux/time.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 timespec_to_ns(const struct timespec *ts)
{
 return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;
}
# 203 "include/linux/time.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
# 233 "include/linux/time.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __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;
}
# 25 "include/linux/ktime.h" 2
# 1 "include/linux/jiffies.h" 1







# 1 "include/linux/timex.h" 1
# 56 "include/linux/timex.h"
# 1 "include/uapi/linux/timex.h" 1
# 64 "include/uapi/linux/timex.h"
struct timex {
 unsigned int modes;
 __kernel_long_t offset;
 __kernel_long_t freq;
 __kernel_long_t maxerror;
 __kernel_long_t esterror;
 int status;
 __kernel_long_t constant;
 __kernel_long_t precision;
 __kernel_long_t tolerance;


 struct timeval time;
 __kernel_long_t tick;

 __kernel_long_t ppsfreq;
 __kernel_long_t jitter;
 int shift;
 __kernel_long_t stabil;
 __kernel_long_t jitcnt;
 __kernel_long_t calcnt;
 __kernel_long_t errcnt;
 __kernel_long_t 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;
};
# 57 "include/linux/timex.h" 2






# 1 "./include/uapi/linux/param.h" 1



# 1 "arch/arm/include/generated/asm/param.h" 1
# 1 "include/asm-generic/param.h" 1



# 1 "include/uapi/asm-generic/param.h" 1
# 5 "include/asm-generic/param.h" 2
# 1 "arch/arm/include/generated/asm/param.h" 2
# 5 "./include/uapi/linux/param.h" 2
# 64 "include/linux/timex.h" 2

# 1 "./arch/arm/include/asm/timex.h" 1
# 15 "./arch/arm/include/asm/timex.h"
typedef unsigned long cycles_t;
# 66 "include/linux/timex.h" 2
# 139 "include/linux/timex.h"
extern unsigned long tick_usec;
extern unsigned long tick_nsec;
# 154 "include/linux/timex.h"
extern int do_adjtimex(struct timex *);
extern void hardpps(const struct timespec *, const struct timespec *);

int read_current_timer(unsigned long *timer_val);
void ntp_notify_cmos_timer(void);
# 9 "include/linux/jiffies.h" 2
# 1 "arch/arm/include/generated/asm/param.h" 1
# 10 "include/linux/jiffies.h" 2
# 57 "include/linux/jiffies.h"
extern int register_refined_jiffies(long clock_tick_rate);
# 76 "include/linux/jiffies.h"
extern u64 __attribute__((section(".data"))) jiffies_64;
extern unsigned long volatile __attribute__((section(".data"))) jiffies;


u64 get_jiffies_64(void);
# 182 "include/linux/jiffies.h"
extern unsigned long preset_lpj;
# 283 "include/linux/jiffies.h"
extern unsigned int jiffies_to_msecs(const unsigned long j);
extern unsigned int jiffies_to_usecs(const unsigned long j);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 jiffies_to_nsecs(const unsigned long j)
{
 return (u64)jiffies_to_usecs(j) * 1000L;
}

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(unsigned long x);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) clock_t jiffies_delta_to_clock_t(long delta)
{
 return jiffies_to_clock_t(({ typeof(0L) _max1 = (0L); typeof(delta) _max2 = (delta); (void) (&_max1 == &_max2); _max1 > _max2 ? _max1 : _max2; }));
}

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);
extern u64 nsecs_to_jiffies64(u64 n);
extern unsigned long nsecs_to_jiffies(u64 n);
# 26 "include/linux/ktime.h" 2
# 37 "include/linux/ktime.h"
union ktime {
 s64 tv64;
};

typedef union ktime ktime_t;
# 50 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_set(const s64 secs, const unsigned long nsecs)
{
 if (__builtin_expect(!!(secs >= (((s64)~((u64)1 << 63)) / 1000000000L)), 0))
  return (ktime_t){ .tv64 = ((s64)~((u64)1 << 63)) };

 return (ktime_t) { .tv64 = secs * 1000000000L + (s64)nsecs };
}
# 81 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t timespec_to_ktime(struct timespec ts)
{
 return ktime_set(ts.tv_sec, ts.tv_nsec);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t timespec64_to_ktime(struct timespec64 ts)
{
 return ktime_set(ts.tv_sec, ts.tv_nsec);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t timeval_to_ktime(struct timeval tv)
{
 return ktime_set(tv.tv_sec, tv.tv_usec * 1000L);
}
# 120 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ktime_equal(const ktime_t cmp1, const ktime_t cmp2)
{
 return cmp1.tv64 == cmp2.tv64;
}
# 135 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
{
 if (cmp1.tv64 < cmp2.tv64)
  return -1;
 if (cmp1.tv64 > cmp2.tv64)
  return 1;
 return 0;
}
# 151 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)
{
 return ktime_compare(cmp1, cmp2) > 0;
}
# 163 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
{
 return ktime_compare(cmp1, cmp2) < 0;
}


extern u64 __ktime_divns(const ktime_t kt, s64 div);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 ktime_divns(const ktime_t kt, s64 div)
{
 if (__builtin_constant_p(div) && !(div >> 32)) {
  u64 ns = kt.tv64;
  ({ unsigned int __r, __b = (div); if (!__builtin_constant_p(__b) || __b == 0 || (7 < 4 && (__b & (__b - 1)) != 0)) { __r = ({ register unsigned int __base asm("r4") = __b; register unsigned long long __n asm("r0") = ns; register unsigned long long __res asm("r2"); register unsigned int __rem asm("r1"); asm( ".ifnc " "%0" "," "r1" "; " ".ifnc " "%0" "r1" ",fpr11; " ".ifnc " "%0" "r1" ",r11fp; " ".ifnc " "%0" "r1" ",ipr12; " ".ifnc " "%0" "r1" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" ".ifnc " "%1" "," "r2" "; " ".ifnc " "%1" "r2" ",fpr11; " ".ifnc " "%1" "r2" ",r11fp; " ".ifnc " "%1" "r2" ",ipr12; " ".ifnc " "%1" "r2" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" ".ifnc " "%2" "," "r0" "; " ".ifnc " "%2" "r0" ",fpr11; " ".ifnc " "%2" "r0" ",r11fp; " ".ifnc " "%2" "r0" ",ipr12; " ".ifnc " "%2" "r0" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" ".ifnc " "%3" "," "r4" "; " ".ifnc " "%3" "r4" ",fpr11; " ".ifnc " "%3" "r4" ",r11fp; " ".ifnc " "%3" "r4" ",ipr12; " ".ifnc " "%3" "r4" ",r12ip; " ".err; " ".endif; " ".endif; " ".endif; " ".endif; " ".endif\n\t" "bl	__do_div64" : "=r" (__rem), "=r" (__res) : "r" (__n), "r" (__base) : "ip", "lr", "cc"); ns = __res; __rem; }); } else if ((__b & (__b - 1)) == 0) { __r = ns; __r &= (__b - 1); ns /= __b; } else { unsigned long long __res, __x, __t, __m, __n = ns; unsigned int __c, __p, __z = 0; __r = __n; __p = 1 << ({ unsigned int __left = (__b), __nr = 0; if (__left & 0xffff0000) __nr += 16, __left >>= 16; if (__left & 0x0000ff00) __nr += 8, __left >>= 8; if (__left & 0x000000f0) __nr += 4, __left >>= 4; if (__left & 0x0000000c) __nr += 2, __left >>= 2; if (__left & 0x00000002) __nr += 1; __nr; }); __m = (~0ULL / __b) * __p; __m += (((~0ULL % __b + 1) * __p) + __b - 1) / __b; __x = ~0ULL / __b * __b - 1; __res = (__m & 0xffffffff) * (__x & 0xffffffff); __res >>= 32; __res += (__m & 0xffffffff) * (__x >> 32); __t = __res; __res += (__x & 0xffffffff) * (__m >> 32); __t = (__res < __t) ? (1ULL << 32) : 0; __res = (__res >> 32) + __t; __res += (__m >> 32) * (__x >> 32); __res /= __p; if (~0ULL % (__b / (__b & -__b)) == 0) { __n /= (__b & -__b); __m = ~0ULL / (__b / (__b & -__b)); __p = 1; __c = 1; } else if (__res != __x / __b) { __c = 1; __m = (~0ULL / __b) * __p; __m += ((~0ULL % __b + 1) * __p) / __b; } else { unsigned int __bits = -(__m & -__m); __bits |= __m >> 32; __bits = (~__bits) << 1; if (!__bits) { __p /= (__m & -__m); __m /= (__m & -__m); } else { __p >>= ({ unsigned int __left = (__bits), __nr = 0; if (__left & 0xffff0000) __nr += 16, __left >>= 16; if (__left & 0x0000ff00) __nr += 8, __left >>= 8; if (__left & 0x000000f0) __nr += 4, __left >>= 4; if (__left & 0x0000000c) __nr += 2, __left >>= 2; if (__left & 0x00000002) __nr += 1; __nr; }); __m >>= ({ unsigned int __left = (__bits), __nr = 0; if (__left & 0xffff0000) __nr += 16, __left >>= 16; if (__left & 0x0000ff00) __nr += 8, __left >>= 8; if (__left & 0x000000f0) __nr += 4, __left >>= 4; if (__left & 0x0000000c) __nr += 2, __left >>= 2; if (__left & 0x00000002) __nr += 1; __nr; }); } __c = 0; } if (!__c) { asm ( "umull	%Q0, %R0, %Q1, %Q2\n\t" "mov	%Q0, #0" : "=&r" (__res) : "r" (__m), "r" (__n) : "cc" ); } else if (!(__m & ((1ULL << 63) | (1ULL << 31)))) { __res = __m; asm ( "umlal	%Q0, %R0, %Q1, %Q2\n\t" "mov	%Q0, #0" : "+&r" (__res) : "r" (__m), "r" (__n) : "cc" ); } else { asm ( "umull	%Q0, %R0, %Q1, %Q2\n\t" "cmn	%Q0, %Q1\n\t" "adcs	%R0, %R0, %R1\n\t" "adc	%Q0, %3, #0" : "=&r" (__res) : "r" (__m), "r" (__n), "r" (__z) : "cc" ); } if (!(__m & ((1ULL << 63) | (1ULL << 31)))) { asm ( "umlal	%R0, %Q0, %R1, %Q2\n\t" "umlal	%R0, %Q0, %Q1, %R2\n\t" "mov	%R0, #0\n\t" "umlal	%Q0, %R0, %R1, %R2" : "+&r" (__res) : "r" (__m), "r" (__n) : "cc" ); } else { asm ( "umlal	%R0, %Q0, %R2, %Q3\n\t" "umlal	%R0, %1, %Q2, %R3\n\t" "mov	%R0, #0\n\t" "adds	%Q0, %1, %Q0\n\t" "adc	%R0, %R0, #0\n\t" "umlal	%Q0, %R0, %R2, %R3" : "+&r" (__res), "+&r" (__z) : "r" (__m), "r" (__n) : "cc" ); } __res /= __p; { unsigned int __res0 = __res; unsigned int __b0 = __b; __r -= __res0 * __b0; } ns = __res; } __r; });
  return ns;
 } else {
  return __ktime_divns(kt, div);
 }
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 ktime_to_us(const ktime_t kt)
{
 return ktime_divns(kt, 1000L);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 ktime_to_ms(const ktime_t kt)
{
 return ktime_divns(kt, 1000000L);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
{
       return ktime_to_us(({ (ktime_t){ .tv64 = (later).tv64 - (earlier).tv64 }; }));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 ktime_ms_delta(const ktime_t later, const ktime_t earlier)
{
 return ktime_to_ms(({ (ktime_t){ .tv64 = (later).tv64 - (earlier).tv64 }; }));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
{
 return ({ (ktime_t){ .tv64 = (kt).tv64 + (usec * 1000L) }; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_add_ms(const ktime_t kt, const u64 msec)
{
 return ({ (ktime_t){ .tv64 = (kt).tv64 + (msec * 1000000L) }; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
{
 return ({ (ktime_t){ .tv64 = (kt).tv64 - (usec * 1000L) }; });
}

extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);
# 229 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((warn_unused_result)) bool ktime_to_timespec_cond(const ktime_t kt,
             struct timespec *ts)
{
 if (kt.tv64) {
  *ts = ns_to_timespec((kt).tv64);
  return true;
 } else {
  return false;
 }
}
# 248 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((warn_unused_result)) bool ktime_to_timespec64_cond(const ktime_t kt,
             struct timespec64 *ts)
{
 if (kt.tv64) {
  *ts = ns_to_timespec64((kt).tv64);
  return true;
 } else {
  return false;
 }
}
# 268 "include/linux/ktime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ns_to_ktime(u64 ns)
{
 static const ktime_t ktime_zero = { .tv64 = 0 };

 return ({ (ktime_t){ .tv64 = (ktime_zero).tv64 + (ns) }; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ms_to_ktime(u64 ms)
{
 static const ktime_t ktime_zero = { .tv64 = 0 };

 return ktime_add_ms(ktime_zero, ms);
}

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





void timekeeping_init(void);
extern int timekeeping_suspended;




extern void do_gettimeofday(struct timeval *tv);
extern int do_settimeofday64(const struct timespec64 *ts);
extern int do_sys_settimeofday(const struct timespec *tv,
          const struct timezone *tz);




unsigned long get_seconds(void);
struct timespec current_kernel_time(void);

struct timespec __current_kernel_time(void);




struct timespec64 get_monotonic_coarse64(void);
extern void getrawmonotonic64(struct timespec64 *ts);
extern void ktime_get_ts64(struct timespec64 *ts);
extern time64_t ktime_get_seconds(void);
extern time64_t ktime_get_real_seconds(void);

extern int __getnstimeofday64(struct timespec64 *tv);
extern void getnstimeofday64(struct timespec64 *tv);
extern void getboottime64(struct timespec64 *ts);
# 85 "include/linux/timekeeping.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int do_settimeofday(const struct timespec *ts)
{
 struct timespec64 ts64;

 ts64 = timespec_to_timespec64(*ts);
 return do_settimeofday64(&ts64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __getnstimeofday(struct timespec *ts)
{
 struct timespec64 ts64;
 int ret = __getnstimeofday64(&ts64);

 *ts = timespec64_to_timespec(ts64);
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void getnstimeofday(struct timespec *ts)
{
 struct timespec64 ts64;

 getnstimeofday64(&ts64);
 *ts = timespec64_to_timespec(ts64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ktime_get_ts(struct timespec *ts)
{
 struct timespec64 ts64;

 ktime_get_ts64(&ts64);
 *ts = timespec64_to_timespec(ts64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ktime_get_real_ts(struct timespec *ts)
{
 struct timespec64 ts64;

 getnstimeofday64(&ts64);
 *ts = timespec64_to_timespec(ts64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void getrawmonotonic(struct timespec *ts)
{
 struct timespec64 ts64;

 getrawmonotonic64(&ts64);
 *ts = timespec64_to_timespec(ts64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct timespec get_monotonic_coarse(void)
{
 return timespec64_to_timespec(get_monotonic_coarse64());
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void getboottime(struct timespec *ts)
{
 struct timespec64 ts64;

 getboottime64(&ts64);
 *ts = timespec64_to_timespec(ts64);
}
# 155 "include/linux/timekeeping.h"
enum tk_offsets {
 TK_OFFS_REAL,
 TK_OFFS_BOOT,
 TK_OFFS_TAI,
 TK_OFFS_MAX,
};

extern ktime_t ktime_get(void);
extern ktime_t ktime_get_with_offset(enum tk_offsets offs);
extern ktime_t ktime_mono_to_any(ktime_t tmono, enum tk_offsets offs);
extern ktime_t ktime_get_raw(void);




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_get_real(void)
{
 return ktime_get_with_offset(TK_OFFS_REAL);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_get_boottime(void)
{
 return ktime_get_with_offset(TK_OFFS_BOOT);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_get_clocktai(void)
{
 return ktime_get_with_offset(TK_OFFS_TAI);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t ktime_mono_to_real(ktime_t mono)
{
 return ktime_mono_to_any(mono, TK_OFFS_REAL);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 ktime_get_ns(void)
{
 return ((ktime_get()).tv64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 ktime_get_real_ns(void)
{
 return ((ktime_get_real()).tv64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 ktime_get_boot_ns(void)
{
 return ((ktime_get_boottime()).tv64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 ktime_get_raw_ns(void)
{
 return ((ktime_get_raw()).tv64);
}

extern u64 ktime_get_mono_fast_ns(void);




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void get_monotonic_boottime(struct timespec *ts)
{
 *ts = ns_to_timespec((ktime_get_boottime()).tv64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void get_monotonic_boottime64(struct timespec64 *ts)
{
 *ts = ns_to_timespec64((ktime_get_boottime()).tv64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void timekeeping_clocktai(struct timespec *ts)
{
 *ts = ns_to_timespec((ktime_get_clocktai()).tv64);
}




extern void timekeeping_inject_sleeptime64(struct timespec64 *delta);




extern void getnstime_raw_and_real(struct timespec *ts_raw,
       struct timespec *ts_real);




extern bool persistent_clock_exist;
extern int persistent_clock_is_local;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool has_persistent_clock(void)
{
 return persistent_clock_exist;
}

extern void read_persistent_clock(struct timespec *ts);
extern void read_boot_clock(struct timespec *ts);
extern int update_persistent_clock(struct timespec now);
# 283 "include/linux/ktime.h" 2
# 6 "include/linux/timer.h" 2
# 1 "include/linux/stddef.h" 1
# 7 "include/linux/timer.h" 2



struct tvec_base;

struct timer_list {




 struct list_head entry;
 unsigned long expires;
 struct tvec_base *base;

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

 int slack;
# 34 "include/linux/timer.h"
};

extern struct tvec_base boot_tvec_bases;
# 94 "include/linux/timer.h"
void init_timer_key(struct timer_list *timer, unsigned int flags,
      const char *name, struct lock_class_key *key);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void destroy_timer_on_stack(struct timer_list *timer) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_timer_on_stack_key(struct timer_list *timer,
        unsigned int flags, const char *name,
        struct lock_class_key *key)
{
 init_timer_key(timer, flags, name, key);
}
# 169 "include/linux/timer.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);

extern void set_timer_slack(struct timer_list *time, int slack_hz);
# 195 "include/linux/timer.h"
extern unsigned long get_next_timer_interrupt(unsigned long now);
# 227 "include/linux/timer.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_timer_stats(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void timer_stats_timer_set_start_info(struct timer_list *timer)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void timer_stats_timer_clear_start_info(struct timer_list *timer)
{
}


extern void add_timer(struct timer_list *timer);

extern int try_to_del_timer_sync(struct timer_list *timer);


  extern int del_timer_sync(struct timer_list *timer);






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);
void delayed_work_timer_fn(unsigned long __data);







enum {
 WORK_STRUCT_PENDING_BIT = 0,
 WORK_STRUCT_DELAYED_BIT = 1,
 WORK_STRUCT_PWQ_BIT = 2,
 WORK_STRUCT_LINKED_BIT = 3,




 WORK_STRUCT_COLOR_SHIFT = 4,


 WORK_STRUCT_COLOR_BITS = 4,

 WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,
 WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT,
 WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT,
 WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,



 WORK_STRUCT_STATIC = 0,






 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1,
 WORK_NO_COLOR = WORK_NR_COLORS,


 WORK_CPU_UNBOUND = 8,






 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
      WORK_STRUCT_COLOR_BITS,


 WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT,

 __WORK_OFFQ_CANCELING = WORK_OFFQ_FLAG_BASE,
 WORK_OFFQ_CANCELING = (1 << __WORK_OFFQ_CANCELING),






 WORK_OFFQ_FLAG_BITS = 1,
 WORK_OFFQ_POOL_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS,
 WORK_OFFQ_LEFT = 32 - WORK_OFFQ_POOL_SHIFT,
 WORK_OFFQ_POOL_BITS = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31,
 WORK_OFFQ_POOL_NONE = (1LU << WORK_OFFQ_POOL_BITS) - 1,


 WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
 WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
 WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT,


 WORK_BUSY_PENDING = 1 << 0,
 WORK_BUSY_RUNNING = 1 << 1,


 WORKER_DESC_LEN = 24,
};

struct work_struct {
 atomic_long_t data;
 struct list_head entry;
 work_func_t func;



};





struct delayed_work {
 struct work_struct work;
 struct timer_list timer;


 struct workqueue_struct *wq;
 int cpu;
};
# 130 "include/linux/workqueue.h"
struct workqueue_attrs {
 int nice;
 cpumask_var_t cpumask;
 bool no_numa;
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
};
# 189 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __init_work(struct work_struct *work, int onstack) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void destroy_work_on_stack(struct work_struct *work) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void destroy_delayed_work_on_stack(struct delayed_work *work) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int work_static(struct work_struct *work) { return 0; }
# 277 "include/linux/workqueue.h"
enum {
 WQ_UNBOUND = 1 << 1,
 WQ_FREEZABLE = 1 << 2,
 WQ_MEM_RECLAIM = 1 << 3,
 WQ_HIGHPRI = 1 << 4,
 WQ_CPU_INTENSIVE = 1 << 5,
 WQ_SYSFS = 1 << 6,
# 310 "include/linux/workqueue.h"
 WQ_POWER_EFFICIENT = 1 << 7,

 __WQ_DRAINING = 1 << 16,
 __WQ_ORDERED = 1 << 17,

 WQ_MAX_ACTIVE = 512,
 WQ_MAX_UNBOUND_PER_CPU = 4,
 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
};
# 352 "include/linux/workqueue.h"
extern struct workqueue_struct *system_wq;
extern struct workqueue_struct *system_highpri_wq;
extern struct workqueue_struct *system_long_wq;
extern struct workqueue_struct *system_unbound_wq;
extern struct workqueue_struct *system_freezable_wq;
extern struct workqueue_struct *system_power_efficient_wq;
extern struct workqueue_struct *system_freezable_power_efficient_wq;

extern struct workqueue_struct *
__alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active,
 struct lock_class_key *key, const char *lock_name, ...) __attribute__((format(printf, 1, 6)));
# 421 "include/linux/workqueue.h"
extern void destroy_workqueue(struct workqueue_struct *wq);

struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask);
void free_workqueue_attrs(struct workqueue_attrs *attrs);
int apply_workqueue_attrs(struct workqueue_struct *wq,
     const struct workqueue_attrs *attrs);

extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
   struct work_struct *work);
extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
   struct delayed_work *work, unsigned long delay);
extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
   struct delayed_work *dwork, unsigned long delay);

extern void flush_workqueue(struct workqueue_struct *wq);
extern void drain_workqueue(struct workqueue_struct *wq);
extern void flush_scheduled_work(void);

extern int schedule_on_each_cpu(work_func_t func);

int execute_in_process_context(work_func_t fn, struct execute_work *);

extern bool flush_work(struct work_struct *work);
extern bool cancel_work_sync(struct work_struct *work);

extern bool flush_delayed_work(struct delayed_work *dwork);
extern bool cancel_delayed_work(struct delayed_work *dwork);
extern bool cancel_delayed_work_sync(struct delayed_work *dwork);

extern void workqueue_set_max_active(struct workqueue_struct *wq,
         int max_active);
extern bool current_is_workqueue_rescuer(void);
extern bool workqueue_congested(int cpu, struct workqueue_struct *wq);
extern unsigned int work_busy(struct work_struct *work);
extern __attribute__((format(printf, 1, 2))) void set_worker_desc(const char *fmt, ...);
extern void print_worker_info(const char *log_lvl, struct task_struct *task);
extern void show_workqueue_state(void);
# 469 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool queue_work(struct workqueue_struct *wq,
         struct work_struct *work)
{
 return queue_work_on(WORK_CPU_UNBOUND, wq, work);
}
# 483 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool queue_delayed_work(struct workqueue_struct *wq,
          struct delayed_work *dwork,
          unsigned long delay)
{
 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
}
# 498 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mod_delayed_work(struct workqueue_struct *wq,
        struct delayed_work *dwork,
        unsigned long delay)
{
 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
}
# 512 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool schedule_work_on(int cpu, struct work_struct *work)
{
 return queue_work_on(cpu, system_wq, work);
}
# 528 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool schedule_work(struct work_struct *work)
{
 return queue_work(system_wq, work);
}
# 542 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,
         unsigned long delay)
{
 return queue_delayed_work_on(cpu, system_wq, dwork, delay);
}
# 556 "include/linux/workqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool schedule_delayed_work(struct delayed_work *dwork,
      unsigned long delay)
{
 return queue_delayed_work(system_wq, dwork, delay);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool keventd_up(void)
{
 return system_wq != ((void *)0);
}







long work_on_cpu(int cpu, long (*fn)(void *), void *arg);



extern void freeze_workqueues_begin(void);
extern bool freeze_workqueues_busy(void);
extern void thaw_workqueues(void);



int workqueue_sysfs_register(struct workqueue_struct *wq);
# 35 "include/linux/srcu.h" 2

struct srcu_struct_array {
 unsigned long c[2];
 unsigned long seq[2];
};

struct rcu_batch {
 struct callback_head *head, **tail;
};



struct srcu_struct {
 unsigned long completed;
 struct srcu_struct_array *per_cpu_ref;
 spinlock_t queue_lock;
 bool running;

 struct rcu_batch batch_queue;

 struct rcu_batch batch_check0;

 struct rcu_batch batch_check1;
 struct rcu_batch batch_done;
 struct delayed_work work;



};
# 80 "include/linux/srcu.h"
int init_srcu_struct(struct srcu_struct *sp);




void process_srcu(struct work_struct *work);
# 128 "include/linux/srcu.h"
void call_srcu(struct srcu_struct *sp, struct callback_head *head,
  void (*func)(struct callback_head *head));

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);
void synchronize_srcu_expedited(struct srcu_struct *sp);
unsigned long srcu_batches_completed(struct srcu_struct *sp);
void srcu_barrier(struct srcu_struct *sp);
# 165 "include/linux/srcu.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int srcu_read_lock_held(struct srcu_struct *sp)
{
 return 1;
}
# 216 "include/linux/srcu.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int srcu_read_lock(struct srcu_struct *sp)
{
 int retval = __srcu_read_lock(sp);

 do { } while (0);
 return retval;
}
# 231 "include/linux/srcu.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void srcu_read_unlock(struct srcu_struct *sp, int idx)

{
 do { } while (0);
 __srcu_read_unlock(sp, idx);
}
# 247 "include/linux/srcu.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void smp_mb__after_srcu_read_unlock(void)
{

}
# 16 "include/linux/notifier.h" 2
# 50 "include/linux/notifier.h"
typedef int (*notifier_fn_t)(struct notifier_block *nb,
   unsigned long action, void *data);

struct notifier_block {
 notifier_fn_t notifier_call;
 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;
};
# 92 "include/linux/notifier.h"
extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
# 118 "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);
# 168 "include/linux/notifier.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int notifier_from_errno(int err)
{
 if (err)
  return 0x8000 | (0x0001 - err);

 return 0x0001;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int notifier_to_errno(int ret)
{
 ret &= ~0x8000;
 return ret > 0x0001 ? 0x0001 - ret : 0;
}
# 212 "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;
struct memory_block;
# 202 "include/linux/memory_hotplug.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgdat_resize_init(struct pglist_data *pgdat) {}

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

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void register_page_bootmem_info_node(struct pglist_data *pgdat)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int try_online_node(int nid)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void get_online_mems(void) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void put_online_mems(void) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_hotplug_begin(void) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_hotplug_done(void) {}
# 250 "include/linux/memory_hotplug.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_mem_section_removable(unsigned long pfn,
     unsigned long nr_pages)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void try_offline_node(int nid) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
{
 return -22;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void remove_memory(int nid, u64 start, u64 size) {}


extern int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn,
  void *arg, int (*func)(struct memory_block *, void *));
extern int add_memory(int nid, u64 start, u64 size);
extern int zone_for_memory(int nid, u64 start, u64 size, int zone_default);
extern int arch_add_memory(int nid, u64 start, u64 size);
extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
extern bool is_memblock_offlined(struct memory_block *mem);
extern void remove_memory(int nid, u64 start, u64 size);
extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn);
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);
# 791 "include/linux/mmzone.h" 2

extern struct mutex zonelists_mutex;
void build_all_zonelists(pg_data_t *pgdat, struct zone *zone);
void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx);
bool zone_watermark_ok(struct zone *z, unsigned int order,
  unsigned long mark, int classzone_idx, int alloc_flags);
bool zone_watermark_ok_safe(struct zone *z, unsigned 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);

extern void lruvec_init(struct lruvec *lruvec);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct zone *lruvec_zone(struct lruvec *lruvec)
{



 return ({ const typeof( ((struct zone *)0)->lruvec ) *__mptr = (lruvec); (struct zone *)( (char *)__mptr - __builtin_offsetof(struct zone,lruvec) );});

}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void memory_present(int nid, unsigned long start, unsigned long end) {}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int local_memory_node(int node_id) { return node_id; };
# 839 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int populated_zone(struct zone *zone)
{
 return (!!zone->present_pages);
}

extern int movable_zone;


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int zone_movable_is_highmem(void)
{



 return (ZONE_MOVABLE - 1) == ZONE_HIGHMEM;

}


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

 return (idx == ZONE_HIGHMEM ||
  (idx == ZONE_MOVABLE && zone_movable_is_highmem()));



}







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

 int zone_off = (char *)zone - (char *)zone->zone_pgdat->node_zones;
 return zone_off == ZONE_HIGHMEM * sizeof(*zone) ||
        (zone_off == ZONE_MOVABLE * sizeof(*zone) &&
  zone_movable_is_highmem());



}


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;
# 916 "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);
# 948 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct zone *zonelist_zone(struct zoneref *zoneref)
{
 return zoneref->zone;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int zonelist_zone_idx(struct zoneref *zoneref)
{
 return zoneref->zone_idx;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int zonelist_node_idx(struct zoneref *zoneref)
{




 return 0;

}
# 980 "include/linux/mmzone.h"
struct zoneref *next_zones_zonelist(struct zoneref *z,
     enum zone_type highest_zoneidx,
     nodemask_t *nodes);
# 996 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
     enum zone_type highest_zoneidx,
     nodemask_t *nodes,
     struct zone **zone)
{
 struct zoneref *z = next_zones_zonelist(zonelist->_zonerefs,
       highest_zoneidx, nodes);
 *zone = zonelist_zone(z);
 return z;
}
# 1042 "include/linux/mmzone.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long early_pfn_to_nid(unsigned long pfn)
{
 return 0;
}
# 1230 "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);
# 1261 "include/linux/mmzone.h"
int memmap_valid_within(unsigned long pfn,
     struct page *page, struct zone *zone);
# 6 "include/linux/gfp.h" 2
# 1 "include/linux/stddef.h" 1
# 7 "include/linux/gfp.h" 2

# 1 "include/linux/topology.h" 1
# 33 "include/linux/topology.h"
# 1 "include/linux/smp.h" 1
# 14 "include/linux/smp.h"
# 1 "include/linux/llist.h" 1
# 61 "include/linux/llist.h"
struct llist_head {
 struct llist_node *first;
};

struct llist_node {
 struct llist_node *next;
};
# 76 "include/linux/llist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_llist_head(struct llist_head *list)
{
 list->first = ((void *)0);
}
# 158 "include/linux/llist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool llist_empty(const struct llist_head *head)
{
 return (*({ __attribute__((unused)) typeof(head->first) __var = ( typeof(head->first)) 0; (volatile typeof(head->first) *)&(head->first); })) == ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct llist_node *llist_next(struct llist_node *node)
{
 return node->next;
}

extern bool llist_add_batch(struct llist_node *new_first,
       struct llist_node *new_last,
       struct llist_head *head);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool llist_add(struct llist_node *new, struct llist_head *head)
{
 return llist_add_batch(new, new, head);
}
# 191 "include/linux/llist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct llist_node *llist_del_all(struct llist_head *head)
{
 return ((__typeof__(*(&head->first)))__xchg((unsigned long)(((void *)0)),(&head->first),sizeof(*(&head->first))));
}

extern struct llist_node *llist_del_first(struct llist_head *head);

struct llist_node *llist_reverse_order(struct llist_node *head);
# 15 "include/linux/smp.h" 2

typedef void (*smp_call_func_t)(void *info);
struct call_single_data {
 struct llist_node llist;
 smp_call_func_t func;
 void *info;
 u16 flags;
};


extern unsigned int total_cpus;

int smp_call_function_single(int cpuid, smp_call_func_t func, void *info,
        int wait);




int on_each_cpu(smp_call_func_t func, void *info, int wait);





void on_each_cpu_mask(const struct cpumask *mask, smp_call_func_t func,
  void *info, bool wait);






void on_each_cpu_cond(bool (*cond_func)(int cpu, void *info),
  smp_call_func_t func, void *info, bool wait,
  gfp_t gfp_flags);

int smp_call_function_single_async(int cpu, struct call_single_data *csd);







# 1 "./arch/arm/include/asm/smp.h" 1
# 23 "./arch/arm/include/asm/smp.h"
struct seq_file;




extern void show_ipi_list(struct seq_file *, int);




 void do_IPI(int ipinr, struct pt_regs *regs);




void handle_IPI(int ipinr, struct pt_regs *regs);




extern void smp_init_cpus(void);





extern void set_smp_cross_call(void (*)(const struct cpumask *, unsigned int));





 void secondary_start_kernel(void);





struct secondary_data {
 union {
  unsigned long mpu_rgn_szr;
  unsigned long pgdir;
 };
 unsigned long swapper_pg_dir;
 void *stack;
};
extern struct secondary_data secondary_data;
extern volatile int pen_release;
extern void secondary_startup(void);

extern int __cpu_disable(void);

extern void __cpu_die(unsigned int cpu);
extern void cpu_die(void);

extern void arch_send_call_function_single_ipi(int cpu);
extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
extern void arch_send_wakeup_ipi_mask(const struct cpumask *mask);

extern int register_ipi_completion(struct completion *completion, int cpu);

struct smp_operations {




 void (*smp_init_cpus)(void);



 void (*smp_prepare_cpus)(unsigned int max_cpus);




 void (*smp_secondary_init)(unsigned int cpu);




 int (*smp_boot_secondary)(unsigned int cpu, struct task_struct *idle);

 int (*cpu_kill)(unsigned int cpu);
 void (*cpu_die)(unsigned int cpu);
 int (*cpu_disable)(unsigned int cpu);


};

struct of_cpu_method {
 const char *method;
 struct smp_operations *ops;
};
# 124 "./arch/arm/include/asm/smp.h"
extern void smp_set_ops(struct smp_operations *);
# 60 "include/linux/smp.h" 2
# 69 "include/linux/smp.h"
extern void smp_send_stop(void);




extern void smp_send_reschedule(int cpu);





extern void smp_prepare_cpus(unsigned int max_cpus);




extern int __cpu_up(unsigned int cpunum, struct task_struct *tidle);




extern void smp_cpus_done(unsigned int max_cpus);




int smp_call_function(smp_call_func_t func, void *info, int wait);
void smp_call_function_many(const struct cpumask *mask,
       smp_call_func_t func, void *info, bool wait);

int smp_call_function_any(const struct cpumask *mask,
     smp_call_func_t func, void *info, int wait);

void kick_all_cpus_sync(void);
void wake_up_all_idle_cpus(void);




void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) call_function_init(void);
void generic_smp_call_function_single_interrupt(void);







void smp_prepare_boot_cpu(void);

extern unsigned int setup_max_cpus;
extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) setup_nr_cpu_ids(void);
extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) smp_init(void);
# 179 "include/linux/smp.h"
  extern unsigned int debug_smp_processor_id(void);
# 192 "include/linux/smp.h"
extern void arch_disable_smp_support(void);

extern void arch_enable_nonboot_cpus_begin(void);
extern void arch_enable_nonboot_cpus_end(void);

void smp_setup_processor_id(void);
# 34 "include/linux/topology.h" 2
# 1 "include/linux/percpu.h" 1
# 9 "include/linux/percpu.h"
# 1 "include/linux/pfn.h" 1
# 10 "include/linux/percpu.h" 2


# 1 "./arch/arm/include/asm/percpu.h" 1
# 24 "./arch/arm/include/asm/percpu.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_my_cpu_offset(unsigned long off)
{

 asm volatile("mcr p15, 0, %0, c13, c0, 4" : : "r" (off) : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __my_cpu_offset(void)
{
 unsigned long off;






 asm("mrc p15, 0, %0, c13, c0, 4" : "=r" (off)
  : "Q" (*(const unsigned long *)current_stack_pointer));

 return off;
}






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





# 1 "include/linux/percpu-defs.h" 1
# 295 "include/linux/percpu-defs.h"
extern void __bad_size_call_parameter(void);


extern void __this_cpu_preempt_check(const char *op);
# 7 "include/asm-generic/percpu.h" 2
# 18 "include/asm-generic/percpu.h"
extern unsigned long __per_cpu_offset[8];
# 51 "./arch/arm/include/asm/percpu.h" 2
# 13 "include/linux/percpu.h" 2
# 57 "include/linux/percpu.h"
extern void *pcpu_base_addr;
extern const unsigned long *pcpu_unit_offsets;

struct pcpu_group_info {
 int nr_units;
 unsigned long base_offset;
 unsigned int *cpu_map;

};

struct pcpu_alloc_info {
 size_t static_size;
 size_t reserved_size;
 size_t dyn_size;
 size_t unit_size;
 size_t atom_size;
 size_t alloc_size;
 size_t __ai_size;
 int nr_groups;
 struct pcpu_group_info groups[];
};

enum pcpu_fc {
 PCPU_FC_AUTO,
 PCPU_FC_EMBED,
 PCPU_FC_PAGE,

 PCPU_FC_NR,
};
extern const char * const pcpu_fc_names[PCPU_FC_NR];

extern enum pcpu_fc pcpu_chosen_fc;

typedef void * (*pcpu_fc_alloc_fn_t)(unsigned int cpu, size_t size,
         size_t align);
typedef void (*pcpu_fc_free_fn_t)(void *ptr, size_t size);
typedef void (*pcpu_fc_populate_pte_fn_t)(unsigned long addr);
typedef int (pcpu_fc_cpu_distance_fn_t)(unsigned int from, unsigned int to);

extern struct pcpu_alloc_info * __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) pcpu_alloc_alloc_info(int nr_groups,
            int nr_units);
extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) pcpu_free_alloc_info(struct pcpu_alloc_info *ai);

extern int __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
      void *base_addr);
# 118 "include/linux/percpu.h"
extern void *__alloc_reserved_percpu(size_t size, size_t align);
extern bool is_kernel_percpu_address(unsigned long addr);


extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) setup_per_cpu_areas(void);

extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) percpu_init_late(void);

extern void *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp);
extern void *__alloc_percpu(size_t size, size_t align);
extern void free_percpu(void *__pdata);
extern phys_addr_t per_cpu_ptr_to_phys(void *addr);
# 139 "include/linux/percpu.h"
extern __attribute__((section(".data..percpu" ""))) __typeof__(printk_func_t) printk_func;
# 35 "include/linux/topology.h" 2
# 1 "./arch/arm/include/asm/topology.h" 1







struct cputopo_arm {
 int thread_id;
 int core_id;
 int socket_id;
 cpumask_t thread_sibling;
 cpumask_t core_sibling;
};

extern struct cputopo_arm cpu_topology[8];






void init_cpu_topology(void);
void store_cpu_topology(unsigned int cpuid);
const struct cpumask *cpu_coregroup_mask(int cpu);
# 34 "./arch/arm/include/asm/topology.h"
# 1 "include/asm-generic/topology.h" 1
# 35 "./arch/arm/include/asm/topology.h" 2
# 36 "include/linux/topology.h" 2
# 49 "include/linux/topology.h"
int arch_update_cpu_topology(void);
# 106 "include/linux/topology.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int numa_node_id(void)
{
 return ((void)((current_thread_info()->cpu)),0);
}
# 166 "include/linux/topology.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int numa_mem_id(void)
{
 return numa_node_id();
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int node_to_mem_node(int node)
{
 return node;
}
# 208 "include/linux/topology.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) const struct cpumask *cpu_cpu_mask(int cpu)
{
 return ((void)((void)(cpu),0), cpu_online_mask);
}
# 9 "include/linux/gfp.h" 2

struct vm_area_struct;
# 148 "include/linux/gfp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int gfpflags_to_migratetype(const 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)) warn_slowpath_null("include/linux/gfp.h", 150); __builtin_expect(!!(__ret_warn_on), 0); });

 if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
  return MIGRATE_UNMOVABLE;


 return (((gfp_flags & (( gfp_t)0x08u)) != 0) << 1) |
  ((gfp_flags & (( gfp_t)0x80000u)) != 0);
}
# 243 "include/linux/gfp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) enum zone_type gfp_zone(gfp_t flags)
{
 enum zone_type z;
 int bit = ( int) (flags & ((( gfp_t)0x01u)|(( gfp_t)0x02u)|(( gfp_t)0x04u)|(( gfp_t)0x08u)));

 z = (( (ZONE_NORMAL << 0 * 2) | (ZONE_NORMAL << 0x01u * 2) | (ZONE_HIGHMEM << 0x02u * 2) | (ZONE_NORMAL << 0x04u * 2) | (ZONE_NORMAL << 0x08u * 2) | (ZONE_NORMAL << (0x08u | 0x01u) * 2) | (ZONE_MOVABLE << (0x08u | 0x02u) * 2) | (ZONE_NORMAL << (0x08u | 0x04u) * 2) ) >> (bit * 2)) &
      ((1 << 2) - 1);
 ((void)(sizeof(( long)((( 1 << (0x01u | 0x02u) | 1 << (0x01u | 0x04u) | 1 << (0x04u | 0x02u) | 1 << (0x01u | 0x04u | 0x02u) | 1 << (0x08u | 0x02u | 0x01u) | 1 << (0x08u | 0x04u | 0x01u) | 1 << (0x08u | 0x04u | 0x02u) | 1 << (0x08u | 0x04u | 0x01u | 0x02u) ) >> bit) & 1))));
 return z;
}
# 261 "include/linux/gfp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int gfp_zonelist(gfp_t flags)
{
 if ((0 || 0) && __builtin_expect(!!(flags & (( gfp_t)0x40000u)), 0))
  return 1;

 return 0;
}
# 278 "include/linux/gfp.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct zonelist *node_zonelist(int nid, gfp_t flags)
{
 return (&contig_page_data)->node_zonelists + gfp_zonelist(flags);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void arch_free_page(struct page *page, int order) { }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
      unsigned int order)
{

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

 return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *alloc_pages_exact_node(int nid, gfp_t gfp_mask,
      unsigned int order)
{
 ((void)(sizeof(( long)(nid < 0 || nid >= (1 << 0) || !node_state((nid), N_ONLINE)))));

 return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
}
# 346 "include/linux/gfp.h"
extern struct page *alloc_kmem_pages(gfp_t gfp_mask, unsigned int order);
extern struct page *alloc_kmem_pages_node(int nid, gfp_t gfp_mask,
       unsigned int order);

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

void * __attribute__ ((__section__(".meminit.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask);







extern void __free_pages(struct page *page, unsigned int order);
extern void free_pages(unsigned long addr, unsigned int order);
extern void free_hot_cold_page(struct page *page, bool cold);
extern void free_hot_cold_page_list(struct list_head *list, bool cold);

extern void __free_kmem_pages(struct page *page, unsigned int order);
extern void free_kmem_pages(unsigned long addr, unsigned int order);




void page_alloc_init(void);
void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
void drain_all_pages(struct zone *zone);
void drain_local_pages(struct zone *zone);
# 387 "include/linux/gfp.h"
extern gfp_t gfp_allowed_mask;


bool gfp_pfmemalloc_allowed(gfp_t gfp_mask);

extern void pm_restrict_gfp_mask(void);
extern void pm_restore_gfp_mask(void);


extern bool pm_suspended_storage(void);
# 407 "include/linux/gfp.h"
extern int alloc_contig_range(unsigned long start, unsigned long end,
         unsigned migratetype);
extern void free_contig_range(unsigned long pfn, unsigned nr_pages);


extern void init_cma_reserved_pageblock(struct page *page);
# 10 "include/linux/mm.h" 2



# 1 "include/linux/rbtree.h" 1
# 33 "include/linux/rbtree.h"
# 1 "include/linux/stddef.h" 1
# 34 "include/linux/rbtree.h" 2

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;
};
# 61 "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 struct rb_node *rb_first_postorder(const struct rb_root *);
extern struct rb_node *rb_next_postorder(const struct rb_node *);


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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}
# 14 "include/linux/mm.h" 2


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



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



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



# 1 "arch/arm/include/generated/asm/auxvec.h" 1
# 1 "./include/uapi/asm-generic/auxvec.h" 1
# 1 "arch/arm/include/generated/asm/auxvec.h" 2
# 5 "include/uapi/linux/auxvec.h" 2
# 5 "include/linux/auxvec.h" 2
# 5 "include/linux/mm_types.h" 2
# 13 "include/linux/mm_types.h"
# 1 "include/linux/uprobes.h" 1
# 31 "include/linux/uprobes.h"
struct vm_area_struct;
struct mm_struct;
struct inode;
struct notifier_block;
struct page;






enum uprobe_filter_ctx {
 UPROBE_FILTER_REGISTER,
 UPROBE_FILTER_UNREGISTER,
 UPROBE_FILTER_MMAP,
};

struct uprobe_consumer {
 int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs);
 int (*ret_handler)(struct uprobe_consumer *self,
    unsigned long func,
    struct pt_regs *regs);
 bool (*filter)(struct uprobe_consumer *self,
    enum uprobe_filter_ctx ctx,
    struct mm_struct *mm);

 struct uprobe_consumer *next;
};
# 135 "include/linux/uprobes.h"
struct uprobes_state {
};



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc)
{
 return -38;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
uprobe_apply(struct inode *inode, loff_t offset, struct uprobe_consumer *uc, bool add)
{
 return -38;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int uprobe_mmap(struct vm_area_struct *vma)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void uprobe_start_dup_mmap(void)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void uprobe_end_dup_mmap(void)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void uprobe_notify_resume(struct pt_regs *regs)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uprobe_deny_signal(void)
{
 return false;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void uprobe_free_utask(struct task_struct *t)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void uprobe_copy_process(struct task_struct *t, unsigned long flags)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void uprobe_clear_state(struct mm_struct *mm)
{
}
# 14 "include/linux/mm_types.h" 2


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





typedef struct {

 atomic64_t id;



 unsigned int vmalloc_seq;
 unsigned long sigpage;
} mm_context_t;
# 17 "include/linux/mm_types.h" 2






struct address_space;
struct mem_cgroup;






typedef void compound_page_dtor(struct page *);
# 46 "include/linux/mm_types.h"
struct page {

 unsigned long flags;

 union {
  struct address_space *mapping;






  void *s_mem;
 };


 struct {
  union {
   unsigned long index;
   void *freelist;
   bool pfmemalloc;
# 75 "include/linux/mm_types.h"
  };

  union {
# 88 "include/linux/mm_types.h"
   unsigned counters;


   struct {

    union {
# 110 "include/linux/mm_types.h"
     atomic_t _mapcount;

     struct {
      unsigned inuse:16;
      unsigned objects:15;
      unsigned frozen:1;
     };
     int units;
    };
    atomic_t _count;
   };
   unsigned int active;
  };
 };


 union {
  struct list_head lru;




  struct {
   struct page *next;




   short int pages;
   short int pobjects;

  };

  struct slab *slab_page;
  struct callback_head callback_head;



  struct {
   compound_page_dtor *compound_dtor;
   unsigned long compound_order;
  };




 };


 union {
  unsigned long private;
# 169 "include/linux/mm_types.h"
  spinlock_t *ptl;




  struct kmem_cache *slab_cache;
  struct page *first_page;
 };
# 208 "include/linux/mm_types.h"
}







;

struct page_frag {
 struct page *page;




 __u16 offset;
 __u16 size;

};

typedef unsigned long vm_flags_t;






struct vm_region {
 struct rb_node vm_rb;
 vm_flags_t vm_flags;
 unsigned long vm_start;
 unsigned long vm_end;
 unsigned long vm_top;
 unsigned long vm_pgoff;
 struct file *vm_file;

 int vm_usage;
 bool vm_icache_flushed : 1;

};







struct vm_area_struct {


 unsigned long vm_start;
 unsigned long vm_end;



 struct vm_area_struct *vm_next, *vm_prev;

 struct rb_node vm_rb;







 unsigned long rb_subtree_gap;



 struct mm_struct *vm_mm;
 pgprot_t vm_page_prot;
 unsigned long vm_flags;





 struct {
  struct rb_node rb;
  unsigned long rb_subtree_last;
 } shared;







 struct list_head anon_vma_chain;

 struct anon_vma *anon_vma;


 const struct vm_operations_struct *vm_ops;


 unsigned long vm_pgoff;

 struct file * vm_file;
 void * vm_private_data;







};

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

enum {
 MM_FILEPAGES,
 MM_ANONPAGES,
 MM_SWAPENTS,
 NR_MM_COUNTERS
};




struct task_rss_stat {
 int events;
 int count[NR_MM_COUNTERS];
};


struct mm_rss_stat {
 atomic_long_t count[NR_MM_COUNTERS];
};

struct kioctx_table;
struct mm_struct {
 struct vm_area_struct *mmap;
 struct rb_root mm_rb;
 u32 vmacache_seqnum;

 unsigned long (*get_unmapped_area) (struct file *filp,
    unsigned long addr, unsigned long len,
    unsigned long pgoff, unsigned long flags);

 unsigned long mmap_base;
 unsigned long mmap_legacy_base;
 unsigned long task_size;
 unsigned long highest_vm_end;
 pgd_t * pgd;
 atomic_t mm_users;
 atomic_t mm_count;
 atomic_long_t nr_ptes;



 int map_count;

 spinlock_t page_table_lock;
 struct rw_semaphore mmap_sem;

 struct list_head mmlist;





 unsigned long hiwater_rss;
 unsigned long hiwater_vm;

 unsigned long total_vm;
 unsigned long locked_vm;
 unsigned long pinned_vm;
 unsigned long shared_vm;
 unsigned long exec_vm;
 unsigned long stack_vm;
 unsigned long def_flags;
 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 + 20 + 1))];





 struct mm_rss_stat rss_stat;

 struct linux_binfmt *binfmt;

 cpumask_var_t cpu_vm_mask_var;


 mm_context_t context;

 unsigned long flags;

 struct core_state *core_state;

 spinlock_t ioctx_lock;
 struct kioctx_table *ioctx_table;
# 432 "include/linux/mm_types.h"
 struct file *exe_file;
# 462 "include/linux/mm_types.h"
 bool tlb_flush_pending;

 struct uprobes_state uprobes_state;




};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mm_init_cpumask(struct mm_struct *mm)
{



 cpumask_clear(mm->cpu_vm_mask_var);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) cpumask_t *mm_cpumask(struct mm_struct *mm)
{
 return mm->cpu_vm_mask_var;
}
# 492 "include/linux/mm_types.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mm_tlb_flush_pending(struct mm_struct *mm)
{
 __asm__ __volatile__("": : :"memory");
 return mm->tlb_flush_pending;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_tlb_flush_pending(struct mm_struct *mm)
{
 mm->tlb_flush_pending = true;





 __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void clear_tlb_flush_pending(struct mm_struct *mm)
{
 __asm__ __volatile__("": : :"memory");
 mm->tlb_flush_pending = false;
}
# 526 "include/linux/mm_types.h"
struct vm_special_mapping
{
 const char *name;
 struct page **pages;
};

enum tlb_flush_reason {
 TLB_FLUSH_ON_TASK_SWITCH,
 TLB_REMOTE_SHOOTDOWN,
 TLB_LOCAL_SHOOTDOWN,
 TLB_LOCAL_MM_SHOOTDOWN,
 NR_TLB_FLUSH_REASONS,
};





typedef struct {
 unsigned long val;
} swp_entry_t;
# 17 "include/linux/mm.h" 2
# 1 "include/linux/range.h" 1



struct range {
 u64 start;
 u64 end;
};

int add_range(struct range *range, int az, int nr_range,
  u64 start, u64 end);


int add_range_with_merge(struct range *range, int az, int nr_range,
    u64 start, u64 end);

void subtract_range(struct range *range, int az, u64 start, u64 end);

int clean_sort_range(struct range *range, int az);

void sort_range(struct range *range, int nr_range);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) resource_size_t cap_resource(u64 val)
{
 if (val > ((resource_size_t)~0))
  return ((resource_size_t)~0);

 return val;
}
# 18 "include/linux/mm.h" 2

# 1 "include/linux/bit_spinlock.h" 1
# 15 "include/linux/bit_spinlock.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void bit_spin_lock(int bitnum, unsigned long *addr)
{







 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);

 while (__builtin_expect(!!(_test_and_set_bit(bitnum,addr)), 0)) {
  do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
  do {
   __asm__ __volatile__("": : :"memory");
  } while (test_bit(bitnum, addr));
  do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 }

 (void)0;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int bit_spin_trylock(int bitnum, unsigned long *addr)
{
 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);

 if (__builtin_expect(!!(_test_and_set_bit(bitnum,addr)), 0)) {
  do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
  return 0;
 }

 (void)0;
 return 1;
}




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

 do { if (__builtin_expect(!!(!test_bit(bitnum, addr)), 0)) do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/bit_spinlock.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "59" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0); } while (0);


 do { __asm__ __volatile__ ("dmb " "ish" : : : "memory"); _clear_bit(bitnum,addr); } while (0);

 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
 (void)0;
}






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

 do { if (__builtin_expect(!!(!test_bit(bitnum, addr)), 0)) do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/bit_spinlock.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "76" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0); } while (0);


 do { __asm__ __volatile__ ("dmb " "ish" : : : "memory"); __clear_bit(bitnum, addr); } while (0);

 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
 (void)0;
}




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

 return test_bit(bitnum, addr);





}
# 20 "include/linux/mm.h" 2
# 1 "include/linux/shrinker.h" 1
# 11 "include/linux/shrinker.h"
struct shrink_control {
 gfp_t gfp_mask;






 unsigned long nr_to_scan;


 int nid;


 struct mem_cgroup *memcg;
};
# 49 "include/linux/shrinker.h"
struct shrinker {
 unsigned long (*count_objects)(struct shrinker *,
           struct shrink_control *sc);
 unsigned long (*scan_objects)(struct shrinker *,
          struct shrink_control *sc);

 int seeks;
 long batch;
 unsigned long flags;


 struct list_head list;

 atomic_long_t *nr_deferred;
};






extern int register_shrinker(struct shrinker *);
extern void unregister_shrinker(struct shrinker *);
# 21 "include/linux/mm.h" 2
# 1 "include/linux/resource.h" 1



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

struct rlimit {
 __kernel_ulong_t rlim_cur;
 __kernel_ulong_t rlim_max;
};



struct rlimit64 {
 __u64 rlim_cur;
 __u64 rlim_max;
};
# 77 "include/uapi/linux/resource.h"
# 1 "arch/arm/include/generated/asm/resource.h" 1
# 1 "include/asm-generic/resource.h" 1



# 1 "include/uapi/asm-generic/resource.h" 1
# 5 "include/asm-generic/resource.h" 2
# 1 "arch/arm/include/generated/asm/resource.h" 2
# 78 "include/uapi/linux/resource.h" 2
# 5 "include/linux/resource.h" 2


struct task_struct;

int getrusage(struct task_struct *p, int who, struct rusage *ru);
int do_prlimit(struct task_struct *tsk, unsigned int resource,
  struct rlimit *new_rlim, struct rlimit *old_rlim);
# 22 "include/linux/mm.h" 2
# 1 "include/linux/page_ext.h" 1




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





struct task_struct;
struct pt_regs;
# 6 "include/linux/page_ext.h" 2

struct pglist_data;
struct page_ext_operations {
 bool (*need)(void);
 void (*init)(void);
};
# 65 "include/linux/page_ext.h"
struct page_ext;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgdat_page_ext_init(struct pglist_data *pgdat)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page_ext *lookup_page_ext(struct page *page)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void page_ext_init(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void page_ext_init_flatmem(void)
{
}
# 23 "include/linux/mm.h" 2

struct mempolicy;
struct anon_vma;
struct anon_vma_chain;
struct file_ra_state;
struct user_struct;
struct writeback_control;


extern unsigned long max_mapnr;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_max_mapnr(unsigned long limit)
{
 max_mapnr = limit;
}




extern unsigned long totalram_pages;
extern void * high_memory;
extern int page_cluster;


extern int sysctl_legacy_va_layout;





# 1 "./arch/arm/include/asm/pgtable.h" 1
# 14 "./arch/arm/include/asm/pgtable.h"
# 1 "./arch/arm/include/asm/proc-fns.h" 1
# 16 "./arch/arm/include/asm/proc-fns.h"
# 1 "./arch/arm/include/asm/glue-proc.h" 1
# 14 "./arch/arm/include/asm/glue-proc.h"
# 1 "./arch/arm/include/asm/glue.h" 1
# 15 "./arch/arm/include/asm/glue-proc.h" 2
# 17 "./arch/arm/include/asm/proc-fns.h" 2




struct mm_struct;




extern struct processor {



 void (*_data_abort)(unsigned long pc);



 unsigned long (*_prefetch_abort)(unsigned long lr);



 void (*_proc_init)(void);



 void (*_proc_fin)(void);



 void (*reset)(unsigned long addr) __attribute__((noreturn));



 int (*_do_idle)(void);







 void (*dcache_clean_area)(void *addr, int size);




 void (*switch_mm)(phys_addr_t pgd_phys, struct mm_struct *mm);







 void (*set_pte_ext)(pte_t *ptep, pte_t pte, unsigned int ext);



 unsigned int suspend_size;
 void (*do_suspend)(void *);
 void (*do_resume)(void *);
} processor;
# 110 "./arch/arm/include/asm/proc-fns.h"
extern void cpu_resume(void);
# 15 "./arch/arm/include/asm/pgtable.h" 2
# 23 "./arch/arm/include/asm/pgtable.h"
# 1 "include/asm-generic/pgtable-nopud.h" 1
# 13 "include/asm-generic/pgtable-nopud.h"
typedef struct { pgd_t pgd; } pud_t;
# 25 "include/asm-generic/pgtable-nopud.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pgd_none(pgd_t pgd) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pgd_bad(pgd_t pgd) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pgd_present(pgd_t pgd) { return 1; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgd_clear(pgd_t *pgd) { }
# 38 "include/asm-generic/pgtable-nopud.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pud_t * pud_offset(pgd_t * pgd, unsigned long address)
{
 return (pud_t *)pgd;
}
# 24 "./arch/arm/include/asm/pgtable.h" 2

# 1 "./arch/arm/include/asm/pgtable-hwdef.h" 1
# 16 "./arch/arm/include/asm/pgtable-hwdef.h"
# 1 "./arch/arm/include/asm/pgtable-2level-hwdef.h" 1
# 17 "./arch/arm/include/asm/pgtable-hwdef.h" 2
# 26 "./arch/arm/include/asm/pgtable.h" 2


# 1 "./arch/arm/include/asm/tlbflush.h" 1
# 15 "./arch/arm/include/asm/tlbflush.h"
# 1 "./arch/arm/include/asm/glue.h" 1
# 16 "./arch/arm/include/asm/tlbflush.h" 2
# 204 "./arch/arm/include/asm/tlbflush.h"
# 1 "include/linux/sched.h" 1



# 1 "include/uapi/linux/sched.h" 1
# 5 "include/linux/sched.h" 2

# 1 "include/linux/sched/prio.h" 1
# 47 "include/linux/sched/prio.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long nice_to_rlimit(long nice)
{
 return (19 - nice + 1);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long rlimit_to_nice(long prio)
{
 return (19 - prio + 1);
}
# 7 "include/linux/sched.h" 2


struct sched_param {
 int sched_priority;
};

# 1 "arch/arm/include/generated/asm/param.h" 1
# 14 "include/linux/sched.h" 2

# 1 "include/linux/capability.h" 1
# 15 "include/linux/capability.h"
# 1 "include/uapi/linux/capability.h" 1
# 18 "include/uapi/linux/capability.h"
struct task_struct;
# 40 "include/uapi/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;
# 69 "include/uapi/linux/capability.h"
struct vfs_cap_data {
 __le32 magic_etc;
 struct {
  __le32 permitted;
  __le32 inheritable;
 } data[2];
};
# 16 "include/linux/capability.h" 2





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





struct file;
struct inode;
struct dentry;
struct user_namespace;

struct user_namespace *current_user_ns(void);

extern const kernel_cap_t __cap_empty_set;
extern const kernel_cap_t __cap_init_eff_set;
# 117 "include/linux/capability.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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;
}
# 165 "include/linux/capability.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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 bool has_capability(struct task_struct *t, int cap);
extern bool has_ns_capability(struct task_struct *t,
         struct user_namespace *ns, int cap);
extern bool has_capability_noaudit(struct task_struct *t, int cap);
extern bool has_ns_capability_noaudit(struct task_struct *t,
          struct user_namespace *ns, int cap);
extern bool capable(int cap);
extern bool ns_capable(struct user_namespace *ns, int cap);
# 245 "include/linux/capability.h"
extern bool capable_wrt_inode_uidgid(const struct inode *inode, int cap);
extern bool file_ns_capable(const struct file *file, struct user_namespace *ns, int cap);


extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
# 16 "include/linux/sched.h" 2





# 1 "include/linux/plist.h" 1
# 81 "include/linux/plist.h"
struct plist_head {
 struct list_head node_list;
};

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






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void plist_node_init(struct plist_node *node, int prio)
{
 node->prio = prio;
 INIT_LIST_HEAD(&node->prio_list);
 INIT_LIST_HEAD(&node->node_list);
}

extern void plist_add(struct plist_node *node, struct plist_head *head);
extern void plist_del(struct plist_node *node, struct plist_head *head);

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





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







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct plist_node *plist_last(const struct plist_head *head)
{
 return ({ const typeof( ((struct plist_node *)0)->node_list ) *__mptr = (head->node_list.prev); (struct plist_node *)( (char *)__mptr - __builtin_offsetof(struct plist_node,node_list) );})
                                  ;
}
# 22 "include/linux/sched.h" 2
# 32 "include/linux/sched.h"
# 1 "include/linux/cputime.h" 1



# 1 "arch/arm/include/generated/asm/cputime.h" 1
# 1 "include/asm-generic/cputime.h" 1







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



typedef unsigned long cputime_t;
# 13 "include/asm-generic/cputime_jiffies.h"
typedef u64 cputime64_t;
# 9 "include/asm-generic/cputime.h" 2
# 1 "arch/arm/include/generated/asm/cputime.h" 2
# 5 "include/linux/cputime.h" 2
# 33 "include/linux/sched.h" 2


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






# 1 "include/uapi/linux/sem.h" 1



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




# 1 "include/linux/uidgid.h" 1
# 15 "include/linux/uidgid.h"
# 1 "include/linux/highuid.h" 1
# 34 "include/linux/highuid.h"
extern int overflowuid;
extern int overflowgid;

extern void __bad_uid(void);
extern void __bad_gid(void);
# 81 "include/linux/highuid.h"
extern int fs_overflowuid;
extern int fs_overflowgid;
# 16 "include/linux/uidgid.h" 2

struct user_namespace;
extern struct user_namespace init_user_ns;

typedef struct {
 uid_t val;
} kuid_t;


typedef struct {
 gid_t val;
} kgid_t;





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) uid_t __kuid_val(kuid_t uid)
{
 return uid.val;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) gid_t __kgid_val(kgid_t gid)
{
 return gid.val;
}
# 60 "include/linux/uidgid.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uid_eq(kuid_t left, kuid_t right)
{
 return __kuid_val(left) == __kuid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool gid_eq(kgid_t left, kgid_t right)
{
 return __kgid_val(left) == __kgid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uid_gt(kuid_t left, kuid_t right)
{
 return __kuid_val(left) > __kuid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool gid_gt(kgid_t left, kgid_t right)
{
 return __kgid_val(left) > __kgid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uid_gte(kuid_t left, kuid_t right)
{
 return __kuid_val(left) >= __kuid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool gid_gte(kgid_t left, kgid_t right)
{
 return __kgid_val(left) >= __kgid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uid_lt(kuid_t left, kuid_t right)
{
 return __kuid_val(left) < __kuid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool gid_lt(kgid_t left, kgid_t right)
{
 return __kgid_val(left) < __kgid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uid_lte(kuid_t left, kuid_t right)
{
 return __kuid_val(left) <= __kuid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool gid_lte(kgid_t left, kgid_t right)
{
 return __kgid_val(left) <= __kgid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool uid_valid(kuid_t uid)
{
 return !uid_eq(uid, (kuid_t){ -1 });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool gid_valid(kgid_t gid)
{
 return !gid_eq(gid, (kgid_t){ -1 });
}
# 142 "include/linux/uidgid.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) kuid_t make_kuid(struct user_namespace *from, uid_t uid)
{
 return (kuid_t){ uid };
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) kgid_t make_kgid(struct user_namespace *from, gid_t gid)
{
 return (kgid_t){ gid };
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) uid_t from_kuid(struct user_namespace *to, kuid_t kuid)
{
 return __kuid_val(kuid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) gid_t from_kgid(struct user_namespace *to, kgid_t kgid)
{
 return __kgid_val(kgid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) uid_t from_kuid_munged(struct user_namespace *to, kuid_t kuid)
{
 uid_t uid = from_kuid(to, kuid);
 if (uid == (uid_t)-1)
  uid = overflowuid;
 return uid;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) gid_t from_kgid_munged(struct user_namespace *to, kgid_t kgid)
{
 gid_t gid = from_kgid(to, kgid);
 if (gid == (gid_t)-1)
  gid = overflowgid;
 return gid;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid)
{
 return true;
}
# 6 "include/linux/ipc.h" 2
# 1 "include/uapi/linux/ipc.h" 1
# 9 "include/uapi/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 "arch/arm/include/generated/asm/ipcbuf.h" 1
# 1 "./include/uapi/asm-generic/ipcbuf.h" 1
# 19 "./include/uapi/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;
 __kernel_ulong_t __unused1;
 __kernel_ulong_t __unused2;
};
# 1 "arch/arm/include/generated/asm/ipcbuf.h" 2
# 22 "include/uapi/linux/ipc.h" 2
# 57 "include/uapi/linux/ipc.h"
struct ipc_kludge {
 struct msgbuf *msgp;
 long msgtyp;
};
# 7 "include/linux/ipc.h" 2




struct kern_ipc_perm
{
 spinlock_t lock;
 bool deleted;
 int id;
 key_t key;
 kuid_t uid;
 kgid_t gid;
 kuid_t cuid;
 kgid_t cgid;
 umode_t mode;
 unsigned long seq;
 void *security;
};
# 5 "include/uapi/linux/sem.h" 2
# 23 "include/uapi/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 "arch/arm/include/generated/asm/sembuf.h" 1
# 1 "./include/uapi/asm-generic/sembuf.h" 1



# 1 "arch/arm/include/generated/asm/bitsperlong.h" 1
# 5 "./include/uapi/asm-generic/sembuf.h" 2
# 23 "./include/uapi/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 "arch/arm/include/generated/asm/sembuf.h" 2
# 36 "include/uapi/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;
};
# 8 "include/linux/sem.h" 2

struct task_struct;


struct sem_array {
 struct kern_ipc_perm __attribute__((__aligned__((1 << 6))))
    sem_perm;
 time_t sem_ctime;
 struct sem *sem_base;
 struct list_head pending_alter;

 struct list_head pending_const;

 struct list_head list_id;
 int sem_nsems;
 int complex_count;
};



struct sysv_sem {
 struct sem_undo_list *undo_list;
};

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





# 1 "include/uapi/linux/shm.h" 1
# 26 "include/uapi/linux/shm.h"
struct shmid_ds {
 struct ipc_perm shm_perm;
 int shm_segsz;
 __kernel_time_t shm_atime;
 __kernel_time_t shm_dtime;
 __kernel_time_t shm_ctime;
 __kernel_ipc_pid_t shm_cpid;
 __kernel_ipc_pid_t shm_lpid;
 unsigned short shm_nattch;
 unsigned short shm_unused;
 void *shm_unused2;
 void *shm_unused3;
};


# 1 "arch/arm/include/generated/asm/shmbuf.h" 1
# 1 "./include/uapi/asm-generic/shmbuf.h" 1



# 1 "arch/arm/include/generated/asm/bitsperlong.h" 1
# 5 "./include/uapi/asm-generic/shmbuf.h" 2
# 25 "./include/uapi/asm-generic/shmbuf.h"
struct shmid64_ds {
 struct ipc64_perm shm_perm;
 size_t shm_segsz;
 __kernel_time_t shm_atime;

 unsigned long __unused1;

 __kernel_time_t shm_dtime;

 unsigned long __unused2;

 __kernel_time_t shm_ctime;

 unsigned long __unused3;

 __kernel_pid_t shm_cpid;
 __kernel_pid_t shm_lpid;
 __kernel_ulong_t shm_nattch;
 __kernel_ulong_t __unused4;
 __kernel_ulong_t __unused5;
};

struct shminfo64 {
 __kernel_ulong_t shmmax;
 __kernel_ulong_t shmmin;
 __kernel_ulong_t shmmni;
 __kernel_ulong_t shmseg;
 __kernel_ulong_t shmall;
 __kernel_ulong_t __unused1;
 __kernel_ulong_t __unused2;
 __kernel_ulong_t __unused3;
 __kernel_ulong_t __unused4;
};
# 1 "arch/arm/include/generated/asm/shmbuf.h" 2
# 42 "include/uapi/linux/shm.h" 2
# 62 "include/uapi/linux/shm.h"
struct shminfo {
 int shmmax;
 int shmmin;
 int shmmni;
 int shmseg;
 int shmall;
};

struct shm_info {
 int used_ids;
 __kernel_ulong_t shm_tot;
 __kernel_ulong_t shm_rss;
 __kernel_ulong_t shm_swp;
 __kernel_ulong_t swap_attempts;
 __kernel_ulong_t swap_successes;
};
# 7 "include/linux/shm.h" 2
# 1 "./arch/arm/include/asm/shmparam.h" 1
# 8 "include/linux/shm.h" 2

struct shmid_kernel
{
 struct kern_ipc_perm shm_perm;
 struct file *shm_file;
 unsigned long shm_nattch;
 unsigned long shm_segsz;
 time_t shm_atim;
 time_t shm_dtim;
 time_t shm_ctim;
 pid_t shm_cprid;
 pid_t shm_lprid;
 struct user_struct *mlock_user;


 struct task_struct *shm_creator;
 struct list_head shm_clist;
};
# 49 "include/linux/shm.h"
struct sysv_shm {
 struct list_head shm_clist;
};

long do_shmat(int shmid, char *shmaddr, int shmflg, unsigned long *addr,
       unsigned long shmlba);
int is_file_shm_hugepages(struct file *file);
void exit_shm(struct task_struct *task);
# 37 "include/linux/sched.h" 2
# 1 "include/linux/signal.h" 1





# 1 "include/uapi/linux/signal.h" 1



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



# 1 "./arch/arm/include/uapi/asm/signal.h" 1






struct siginfo;
# 93 "./arch/arm/include/uapi/asm/signal.h"
# 1 "./include/uapi/asm-generic/signal-defs.h" 1
# 17 "./include/uapi/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;
# 94 "./arch/arm/include/uapi/asm/signal.h" 2
# 113 "./arch/arm/include/uapi/asm/signal.h"
typedef struct sigaltstack {
 void *ss_sp;
 int ss_flags;
 size_t ss_size;
} stack_t;
# 5 "./arch/arm/include/asm/signal.h" 2
# 13 "./arch/arm/include/asm/signal.h"
typedef unsigned long old_sigset_t;

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



# 1 "./arch/arm/include/uapi/asm/sigcontext.h" 1
# 9 "./arch/arm/include/uapi/asm/sigcontext.h"
struct sigcontext {
 unsigned long trap_no;
 unsigned long error_code;
 unsigned long oldmask;
 unsigned long arm_r0;
 unsigned long arm_r1;
 unsigned long arm_r2;
 unsigned long arm_r3;
 unsigned long arm_r4;
 unsigned long arm_r5;
 unsigned long arm_r6;
 unsigned long arm_r7;
 unsigned long arm_r8;
 unsigned long arm_r9;
 unsigned long arm_r10;
 unsigned long arm_fp;
 unsigned long arm_ip;
 unsigned long arm_sp;
 unsigned long arm_lr;
 unsigned long arm_pc;
 unsigned long arm_cpsr;
 unsigned long fault_address;
};
# 22 "./arch/arm/include/asm/signal.h" 2
# 5 "include/uapi/linux/signal.h" 2
# 1 "arch/arm/include/generated/asm/siginfo.h" 1
# 1 "include/asm-generic/siginfo.h" 1



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






typedef union sigval {
 int sival_int;
 void *sival_ptr;
} sigval_t;
# 48 "include/uapi/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;
   struct {
    void *_lower;
    void *_upper;
   } _addr_bnd;
  } _sigfault;


  struct {
   long _band;
   int _fd;
  } _sigpoll;


  struct {
   void *_call_addr;
   int _syscall;
   unsigned int _arch;
  } _sigsys;
 } _sifields;
} siginfo_t;
# 285 "include/uapi/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;
# 5 "include/asm-generic/siginfo.h" 2
# 17 "include/asm-generic/siginfo.h"
struct siginfo;
void do_schedule_next_timer(struct siginfo *info);





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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, const struct siginfo *from);
# 1 "arch/arm/include/generated/asm/siginfo.h" 2
# 6 "include/uapi/linux/signal.h" 2
# 7 "include/linux/signal.h" 2

struct task_struct;


extern int print_fatal_signals;




struct sigqueue {
 struct list_head list;
 int flags;
 siginfo_t info;
 struct user_struct *user;
};




struct sigpending {
 struct list_head list;
 sigset_t signal;
};
# 40 "include/linux/signal.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int sigisemptyset(sigset_t *set)
{
 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:
  do { bool __cond = !(!(1)); extern void __compiletime_assert_80(void) __attribute__((error("BUILD_BUG failed"))); if (__cond) __compiletime_assert_80(); do { } while (0); } while (0);
  return 0;
 }
}
# 114 "include/linux/signal.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { 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: do { bool __cond = !(!(1)); extern void __compiletime_assert_114(void) __attribute__((error("BUILD_BUG failed"))); if (__cond) __compiletime_assert_114(); do { } while (0); } while (0); } }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { 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: do { bool __cond = !(!(1)); extern void __compiletime_assert_117(void) __attribute__((error("BUILD_BUG failed"))); if (__cond) __compiletime_assert_117(); do { } while (0); } while (0); } }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sigandnsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { 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: do { bool __cond = !(!(1)); extern void __compiletime_assert_120(void) __attribute__((error("BUILD_BUG failed"))); if (__cond) __compiletime_assert_120(); do { } while (0); } while (0); } }
# 142 "include/linux/signal.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void signotset(sigset_t *set) { 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: do { bool __cond = !(!(1)); extern void __compiletime_assert_142(void) __attribute__((error("BUILD_BUG failed"))); if (__cond) __compiletime_assert_142(); do { } while (0); } while (0); } }




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sigemptyset(sigset_t *set)
{
 switch ((64 / 32)) {
 default:
  ({ void *__p = (set); size_t __n = sizeof(sigset_t); if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });
  break;
 case 2: set->sig[1] = 0;
 case 1: set->sig[0] = 0;
  break;
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sigfillset(sigset_t *set)
{
 switch ((64 / 32)) {
 default:
  ({ void *__p = (set); size_t __n = sizeof(sigset_t); if ((__n) != 0) { if (__builtin_constant_p((-1)) && (-1) == 0) __memzero((__p),(__n)); else memset((__p),(-1),(__n)); } (__p); });
  break;
 case 2: set->sig[1] = -1;
 case 1: set->sig[0] = -1;
  break;
 }
}



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

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

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void siginitset(sigset_t *set, unsigned long mask)
{
 set->sig[0] = mask;
 switch ((64 / 32)) {
 default:
  ({ void *__p = (&set->sig[1]); size_t __n = sizeof(long)*((64 / 32)-1); if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });
  break;
 case 2: set->sig[1] = 0;
 case 1: ;
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void siginitsetinv(sigset_t *set, unsigned long mask)
{
 set->sig[0] = ~mask;
 switch ((64 / 32)) {
 default:
  ({ void *__p = (&set->sig[1]); size_t __n = sizeof(long)*((64 / 32)-1); if ((__n) != 0) { if (__builtin_constant_p((-1)) && (-1) == 0) __memzero((__p),(__n)); else memset((__p),(-1),(__n)); } (__p); });
  break;
 case 2: set->sig[1] = -1;
 case 1: ;
 }
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int valid_signal(unsigned long sig)
{
 return sig <= 64 ? 1 : 0;
}

struct timespec;
struct pt_regs;

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 int do_sigtimedwait(const sigset_t *, siginfo_t *,
    const struct timespec *);
extern int sigprocmask(int, sigset_t *, sigset_t *);
extern void set_current_blocked(sigset_t *);
extern void __set_current_blocked(const sigset_t *);
extern int show_unhandled_signals;
extern int sigsuspend(sigset_t *);

struct sigaction {

 __sighandler_t sa_handler;
 unsigned long sa_flags;





 __sigrestore_t sa_restorer;

 sigset_t sa_mask;
};

struct k_sigaction {
 struct sigaction sa;



};


struct old_sigaction {
 __sighandler_t sa_handler;
 old_sigset_t sa_mask;
 unsigned long sa_flags;
 __sigrestore_t sa_restorer;
};


struct ksignal {
 struct k_sigaction ka;
 siginfo_t info;
 int sig;
};

extern int get_signal(struct ksignal *ksig);
extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
extern void exit_signals(struct task_struct *tsk);
extern void kernel_sigaction(int, __sighandler_t);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void allow_signal(int sig)
{





 kernel_sigaction(sig, ( __sighandler_t)2);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void disallow_signal(int sig)
{
 kernel_sigaction(sig, (( __sighandler_t)1));
}

extern struct kmem_cache *sighand_cachep;

int unhandled_signal(struct task_struct *tsk, int sig);
# 427 "include/linux/signal.h"
void signals_init(void);

int restore_altstack(const stack_t *);
int __save_altstack(stack_t *, unsigned long);
# 441 "include/linux/signal.h"
struct seq_file;
extern void render_sigset_t(struct seq_file *, const char *, sigset_t *);
# 38 "include/linux/sched.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 callback_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)) __attribute__((no_instrument_function)) struct pid *get_pid(struct pid *pid)
{
 if (pid)
  atomic_add(1, &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);
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;
# 110 "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, unsigned int last);

extern struct pid *alloc_pid(struct pid_namespace *ns);
extern void free_pid(struct pid *pid);
extern void disable_pid_allocation(struct pid_namespace *ns);
# 134 "include/linux/pid.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool is_child_reaper(struct pid *pid)
{
 return pid->numbers[pid->level].nr == 1;
}
# 164 "include/linux/pid.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
# 41 "include/linux/sched.h" 2


# 1 "include/linux/proportions.h" 1
# 12 "include/linux/proportions.h"
# 1 "include/linux/percpu_counter.h" 1
# 19 "include/linux/percpu_counter.h"
struct percpu_counter {
 raw_spinlock_t lock;
 s64 count;

 struct list_head list;

 s32 *counters;
};

extern int percpu_counter_batch;

int __percpu_counter_init(struct percpu_counter *fbc, s64 amount, gfp_t gfp,
     struct lock_class_key *key);
# 40 "include/linux/percpu_counter.h"
void percpu_counter_destroy(struct percpu_counter *fbc);
void percpu_counter_set(struct percpu_counter *fbc, s64 amount);
void __percpu_counter_add(struct percpu_counter *fbc, s64 amount, s32 batch);
s64 __percpu_counter_sum(struct percpu_counter *fbc);
int percpu_counter_compare(struct percpu_counter *fbc, s64 rhs);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_counter_add(struct percpu_counter *fbc, s64 amount)
{
 __percpu_counter_add(fbc, amount, percpu_counter_batch);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 percpu_counter_sum_positive(struct percpu_counter *fbc)
{
 s64 ret = __percpu_counter_sum(fbc);
 return ret < 0 ? 0 : ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 percpu_counter_sum(struct percpu_counter *fbc)
{
 return __percpu_counter_sum(fbc);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 percpu_counter_read(struct percpu_counter *fbc)
{
 return fbc->count;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 percpu_counter_read_positive(struct percpu_counter *fbc)
{
 s64 ret = fbc->count;

 __asm__ __volatile__("": : :"memory");
 if (ret >= 0)
  return ret;
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int percpu_counter_initialized(struct percpu_counter *fbc)
{
 return (fbc->counters != ((void *)0));
}
# 164 "include/linux/percpu_counter.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_counter_inc(struct percpu_counter *fbc)
{
 percpu_counter_add(fbc, 1);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_counter_dec(struct percpu_counter *fbc)
{
 percpu_counter_add(fbc, -1);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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, gfp_t gfp);
void prop_change_shift(struct prop_descriptor *pd, int new_shift);





struct prop_local_percpu {



 struct percpu_counter events;




 int shift;
 unsigned long period;
 raw_spinlock_t lock;
};

int prop_local_init_percpu(struct prop_local_percpu *pl, gfp_t gfp);
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)) __attribute__((no_instrument_function))
void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
 __prop_inc_percpu(pd, pl);
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } while (0);
}
# 94 "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;
 raw_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)) __attribute__((no_instrument_function))
void prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl)
{
 unsigned long flags;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
 __prop_inc_single(pd, pl);
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } while (0);
}
# 44 "include/linux/sched.h" 2
# 1 "include/linux/seccomp.h" 1



# 1 "include/uapi/linux/seccomp.h" 1
# 47 "include/uapi/linux/seccomp.h"
struct seccomp_data {
 int nr;
 __u32 arch;
 __u64 instruction_pointer;
 __u64 args[6];
};
# 5 "include/linux/seccomp.h" 2
# 60 "include/linux/seccomp.h"
struct seccomp { };
struct seccomp_filter { };


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int secure_computing(void) { return 0; }




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long prctl_get_seccomp(void)
{
 return -22;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long prctl_set_seccomp(unsigned long arg2, char *arg3)
{
 return -22;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int seccomp_mode(struct seccomp *s)
{
 return 0;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void put_seccomp_filter(struct task_struct *tsk)
{
 return;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void get_seccomp_filter(struct task_struct *tsk)
{
 return;
}
# 45 "include/linux/sched.h" 2

# 1 "include/linux/rculist.h" 1
# 30 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void INIT_LIST_HEAD_RCU(struct list_head *list)
{
 ({ typeof(list->next) __val = (list); __write_once_size(&(list->next), &__val, sizeof(__val)); __val; });
 ({ typeof(list->prev) __val = (list); __write_once_size(&(list->prev), &__val, sizeof(__val)); __val; });
}
# 49 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __list_add_rcu(struct list_head *new,
  struct list_head *prev, struct list_head *next)
{
 new->next = next;
 new->prev = prev;
 do { do { bool __cond = !((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long))); extern void __compiletime_assert_54(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_54(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&(*((struct list_head **)(&(prev)->next)))) __var = ( typeof(*&(*((struct list_head **)(&(prev)->next))))) 0; (volatile typeof(*&(*((struct list_head **)(&(prev)->next)))) *)&(*&(*((struct list_head **)(&(prev)->next)))); })) = ((typeof(*(new)) *)(new)); } while (0);
 next->prev = new;
}
# 78 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_add_rcu(struct list_head *new, struct list_head *head)
{
 __list_add_rcu(new, head, head->next);
}
# 99 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_add_tail_rcu(struct list_head *new,
     struct list_head *head)
{
 __list_add_rcu(new, head->prev, head);
}
# 129 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_del_rcu(struct list_head *entry)
{
 __list_del_entry(entry);
 entry->prev = ((void *) 0x00200200 + 0);
}
# 155 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_del_init_rcu(struct hlist_node *n)
{
 if (!hlist_unhashed(n)) {
  __hlist_del(n);
  n->pprev = ((void *)0);
 }
}
# 171 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void list_replace_rcu(struct list_head *old,
    struct list_head *new)
{
 new->next = old->next;
 new->prev = old->prev;
 do { do { bool __cond = !((sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long))); extern void __compiletime_assert_176(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_176(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&(*((struct list_head **)(&(new->prev)->next)))) __var = ( typeof(*&(*((struct list_head **)(&(new->prev)->next))))) 0; (volatile typeof(*&(*((struct list_head **)(&(new->prev)->next)))) *)&(*&(*((struct list_head **)(&(new->prev)->next)))); })) = ((typeof(*(new)) *)(new)); } while (0);
 new->next->prev = new;
 old->prev = ((void *) 0x00200200 + 0);
}
# 198 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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(list))
  return;







 INIT_LIST_HEAD_RCU(list);
# 224 "include/linux/rculist.h"
 sync();
# 234 "include/linux/rculist.h"
 last->next = at;
 do { do { bool __cond = !((sizeof(*&(*((struct list_head **)(&(head)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(head)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(head)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(head)->next)))) == sizeof(long))); extern void __compiletime_assert_235(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_235(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&(*((struct list_head **)(&(head)->next)))) __var = ( typeof(*&(*((struct list_head **)(&(head)->next))))) 0; (volatile typeof(*&(*((struct list_head **)(&(head)->next)))) *)&(*&(*((struct list_head **)(&(head)->next)))); })) = ((typeof(*(first)) *)(first)); } while (0);
 first->prev = head;
 at->prev = last;
}
# 343 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_del_rcu(struct hlist_node *n)
{
 __hlist_del(n);
 n->pprev = ((void *) 0x00200200 + 0);
}
# 356 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
 do { do { bool __cond = !((sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(char) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(short) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(int) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long))); extern void __compiletime_assert_363(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_363(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&*(struct hlist_node **)new->pprev) __var = ( typeof(*&*(struct hlist_node **)new->pprev)) 0; (volatile typeof(*&*(struct hlist_node **)new->pprev) *)&(*&*(struct hlist_node **)new->pprev); })) = ((typeof(*(new)) *)(new)); } while (0);
 if (next)
  new->next->pprev = &new->next;
 old->pprev = ((void *) 0x00200200 + 0);
}
# 395 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
 do { do { bool __cond = !((sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long))); extern void __compiletime_assert_402(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_402(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&(*((struct hlist_node **)(&(h)->first)))) __var = ( typeof(*&(*((struct hlist_node **)(&(h)->first))))) 0; (volatile typeof(*&(*((struct hlist_node **)(&(h)->first)))) *)&(*&(*((struct hlist_node **)(&(h)->first)))); })) = ((typeof(*(n)) *)(n)); } while (0);
 if (first)
  first->pprev = &n->next;
}
# 425 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_add_before_rcu(struct hlist_node *n,
     struct hlist_node *next)
{
 n->pprev = next->pprev;
 n->next = next;
 do { do { bool __cond = !((sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long))); extern void __compiletime_assert_430(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_430(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&(*((struct hlist_node **)((n)->pprev)))) __var = ( typeof(*&(*((struct hlist_node **)((n)->pprev))))) 0; (volatile typeof(*&(*((struct hlist_node **)((n)->pprev)))) *)&(*&(*((struct hlist_node **)((n)->pprev)))); })) = ((typeof(*(n)) *)(n)); } while (0);
 next->pprev = &n->next;
}
# 452 "include/linux/rculist.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_add_behind_rcu(struct hlist_node *n,
     struct hlist_node *prev)
{
 n->next = prev->next;
 n->pprev = &prev->next;
 do { do { bool __cond = !((sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long))); extern void __compiletime_assert_457(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_457(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&(*((struct hlist_node **)(&(prev)->next)))) __var = ( typeof(*&(*((struct hlist_node **)(&(prev)->next))))) 0; (volatile typeof(*&(*((struct hlist_node **)(&(prev)->next)))) *)&(*&(*((struct hlist_node **)(&(prev)->next)))); })) = ((typeof(*(n)) *)(n)); } while (0);
 if (n->next)
  n->next->pprev = &n->next;
}
# 47 "include/linux/sched.h" 2
# 1 "include/linux/rtmutex.h" 1
# 19 "include/linux/rtmutex.h"
extern int max_lock_depth;
# 29 "include/linux/rtmutex.h"
struct rt_mutex {
 raw_spinlock_t wait_lock;
 struct rb_root waiters;
 struct rb_node *waiters_leftmost;
 struct task_struct *owner;

 int save_state;
 const char *name, *file;
 int line;
 void *magic;

};

struct rt_mutex_waiter;
struct hrtimer_sleeper;


 extern int rt_mutex_debug_check_no_locks_freed(const void *from,
      unsigned long len);
 extern void rt_mutex_debug_check_no_locks_held(struct task_struct *task);
# 62 "include/linux/rtmutex.h"
 extern void rt_mutex_debug_task_free(struct task_struct *tsk);
# 84 "include/linux/rtmutex.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
extern int rt_mutex_timed_lock(struct rt_mutex *lock,
          struct hrtimer_sleeper *timeout);

extern int rt_mutex_trylock(struct rt_mutex *lock);

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





# 1 "include/linux/hrtimer.h" 1
# 25 "include/linux/hrtimer.h"
# 1 "include/linux/timerqueue.h" 1







struct timerqueue_node {
 struct rb_node node;
 ktime_t expires;
};

struct timerqueue_head {
 struct rb_root head;
 struct timerqueue_node *next;
};


extern void timerqueue_add(struct timerqueue_head *head,
    struct timerqueue_node *node);
extern void timerqueue_del(struct timerqueue_head *head,
    struct timerqueue_node *node);
extern struct timerqueue_node *timerqueue_iterate_next(
      struct timerqueue_node *node);
# 34 "include/linux/timerqueue.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function))
struct timerqueue_node *timerqueue_getnext(struct timerqueue_head *head)
{
 return head->next;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void timerqueue_init(struct timerqueue_node *node)
{
 ((&node->node)->__rb_parent_color = (unsigned long)(&node->node));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void timerqueue_init_head(struct timerqueue_head *head)
{
 head->head = (struct rb_root) { ((void *)0), };
 head->next = ((void *)0);
}
# 26 "include/linux/hrtimer.h" 2

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,
};
# 108 "include/linux/hrtimer.h"
struct hrtimer {
 struct timerqueue_node node;
 ktime_t _softexpires;
 enum hrtimer_restart (*function)(struct hrtimer *);
 struct hrtimer_clock_base *base;
 unsigned long state;





};
# 128 "include/linux/hrtimer.h"
struct hrtimer_sleeper {
 struct hrtimer timer;
 struct task_struct *task;
};
# 145 "include/linux/hrtimer.h"
struct hrtimer_clock_base {
 struct hrtimer_cpu_base *cpu_base;
 int index;
 clockid_t clockid;
 struct timerqueue_head active;
 ktime_t resolution;
 ktime_t (*get_time)(void);
 ktime_t softirq_time;
 ktime_t offset;
};

enum hrtimer_base_type {
 HRTIMER_BASE_MONOTONIC,
 HRTIMER_BASE_REALTIME,
 HRTIMER_BASE_BOOTTIME,
 HRTIMER_BASE_TAI,
 HRTIMER_MAX_CLOCK_BASES,
};
# 182 "include/linux/hrtimer.h"
struct hrtimer_cpu_base {
 raw_spinlock_t lock;
 unsigned int cpu;
 unsigned int active_bases;
 unsigned int clock_was_set;

 ktime_t expires_next;
 int in_hrtirq;
 int hres_active;
 int hang_detected;
 unsigned long nr_events;
 unsigned long nr_retries;
 unsigned long nr_hangs;
 ktime_t max_hang_time;

 struct hrtimer_clock_base clock_base[HRTIMER_MAX_CLOCK_BASES];
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
{
 timer->node.expires = time;
 timer->_softexpires = time;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
{
 timer->_softexpires = time;
 timer->node.expires = ktime_add_safe(time, delta);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, unsigned long delta)
{
 timer->_softexpires = time;
 timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
{
 timer->node.expires.tv64 = tv64;
 timer->_softexpires.tv64 = tv64;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
{
 timer->node.expires = ktime_add_safe(timer->node.expires, time);
 timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
{
 timer->node.expires = ({ (ktime_t){ .tv64 = (timer->node.expires).tv64 + (ns) }; });
 timer->_softexpires = ({ (ktime_t){ .tv64 = (timer->_softexpires).tv64 + (ns) }; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t hrtimer_get_expires(const struct hrtimer *timer)
{
 return timer->node.expires;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
{
 return timer->_softexpires;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
{
 return timer->node.expires.tv64;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
{
 return timer->_softexpires.tv64;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
{
 return ((timer->node.expires).tv64);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
{
 return ({ (ktime_t){ .tv64 = (timer->node.expires).tv64 - (timer->base->get_time()).tv64 }; });
}


struct clock_event_device;

extern void hrtimer_interrupt(struct clock_event_device *dev);




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
{
 return timer->base->get_time();
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int hrtimer_is_hres_active(struct hrtimer *timer)
{
 return timer->base->cpu_base->hres_active;
}

extern void hrtimer_peek_ahead_timers(void);
# 296 "include/linux/hrtimer.h"
extern void clock_was_set_delayed(void);
# 323 "include/linux/hrtimer.h"
extern void clock_was_set(void);

extern void timerfd_clock_was_set(void);



extern void hrtimers_resume(void);

extern __attribute__((section(".data..percpu" ""))) __typeof__(struct tick_device) tick_cpu_device;





extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
    enum hrtimer_mode mode);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hrtimer_init_on_stack(struct hrtimer *timer,
      clockid_t which_clock,
      enum hrtimer_mode mode)
{
 hrtimer_init(timer, which_clock, mode);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void destroy_hrtimer_on_stack(struct hrtimer *timer) { }



extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
    const enum hrtimer_mode mode);
extern int hrtimer_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)) __attribute__((no_instrument_function)) 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_t){ .tv64 = (hard).tv64 - (soft).tv64 }; })).tv64);
 return hrtimer_start_range_ns(timer, soft, delta, mode);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int hrtimer_active(const struct hrtimer *timer)
{
 return timer->state != 0x00;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int hrtimer_is_queued(struct hrtimer *timer)
{
 return timer->state & 0x01;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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_range_clock(ktime_t *expires,
  unsigned long delta, const enum hrtimer_mode mode, int clock);
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 void sysrq_timer_list_show(void);
# 54 "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"
};
# 55 "include/linux/sched.h" 2
# 1 "include/linux/latencytop.h" 1
# 13 "include/linux/latencytop.h"
struct task_struct;
# 42 "include/linux/latencytop.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
account_scheduler_latency(struct task_struct *task, int usecs, int inter)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void clear_all_latency_tracing(struct task_struct *p)
{
}
# 56 "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
# 28 "include/linux/sysctl.h"
# 1 "include/uapi/linux/sysctl.h" 1
# 29 "include/uapi/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];
};





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,
 KERN_PANIC_ON_WARN=77,
};




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


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_ACCEPT_RA_FROM_LOCAL=26,
 __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,
};


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,
};
# 29 "include/linux/sysctl.h" 2


struct ctl_table;
struct nsproxy;
struct ctl_table_root;
struct ctl_table_header;
struct ctl_dir;

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 proc_do_large_bitmap(struct ctl_table *, int,
    void *, size_t *, loff_t *);
# 87 "include/linux/sysctl.h"
struct ctl_table_poll {
 atomic_t event;
 wait_queue_head_t wait;
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *proc_sys_poll_event(struct ctl_table_poll *poll)
{
 return (void *)(unsigned long)(*({ __attribute__((unused)) typeof((&poll->event)->counter) __var = ( typeof((&poll->event)->counter)) 0; (volatile typeof((&poll->event)->counter) *)&((&poll->event)->counter); }));
}
# 105 "include/linux/sysctl.h"
struct ctl_table
{
 const char *procname;
 void *data;
 int maxlen;
 umode_t mode;
 struct ctl_table *child;
 proc_handler *proc_handler;
 struct ctl_table_poll *poll;
 void *extra1;
 void *extra2;
};

struct ctl_node {
 struct rb_node node;
 struct ctl_table_header *header;
};



struct ctl_table_header
{
 union {
  struct {
   struct ctl_table *ctl_table;
   int used;
   int count;
   int nreg;
  };
  struct callback_head rcu;
 };
 struct completion *unregistering;
 struct ctl_table *ctl_table_arg;
 struct ctl_table_root *root;
 struct ctl_table_set *set;
 struct ctl_dir *parent;
 struct ctl_node *node;
};

struct ctl_dir {

 struct ctl_table_header header;
 struct rb_root root;
};

struct ctl_table_set {
 int (*is_seen)(struct ctl_table_set *);
 struct ctl_dir dir;
};

struct ctl_table_root {
 struct ctl_table_set default_set;
 struct ctl_table_set *(*lookup)(struct ctl_table_root *root,
        struct nsproxy *namespaces);
 int (*permissions)(struct ctl_table_header *head, struct ctl_table *table);
};


struct ctl_path {
 const char *procname;
};



void proc_sys_poll_notify(struct ctl_table_poll *poll);

extern void setup_sysctl_set(struct ctl_table_set *p,
 struct ctl_table_root *root,
 int (*is_seen)(struct ctl_table_set *));
extern void retire_sysctl_set(struct ctl_table_set *set);

void register_sysctl_root(struct ctl_table_root *root);
struct ctl_table_header *__register_sysctl_table(
 struct ctl_table_set *set,
 const char *path, struct ctl_table *table);
struct ctl_table_header *__register_sysctl_paths(
 struct ctl_table_set *set,
 const struct ctl_path *path, struct ctl_table *table);
struct ctl_table_header *register_sysctl(const char *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);

extern int sysctl_init(void);
# 23 "include/linux/key.h" 2


# 1 "include/linux/assoc_array.h" 1
# 26 "include/linux/key.h" 2





typedef int32_t key_serial_t;


typedef uint32_t key_perm_t;

struct key;
# 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;
# 29 "include/linux/selinux.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
 kgid_t small_block[32];
 kgid_t *blocks[0];
};
# 49 "include/linux/cred.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct group_info *get_group_info(struct group_info *gi)
{
 atomic_add(1, &gi->usage);
 return gi;
}
# 65 "include/linux/cred.h"
extern struct group_info init_groups;

extern struct group_info *groups_alloc(int);
extern void groups_free(struct group_info *);

extern int in_group_p(kgid_t);
extern int in_egroup_p(kgid_t);
# 86 "include/linux/cred.h"
extern int set_current_groups(struct group_info *);
extern void set_groups(struct cred *, struct group_info *);
extern int groups_search(const struct group_info *, kgid_t);
extern bool may_setgroups(void);
# 118 "include/linux/cred.h"
struct cred {
 atomic_t usage;







 kuid_t uid;
 kgid_t gid;
 kuid_t suid;
 kgid_t sgid;
 kuid_t euid;
 kgid_t egid;
 kuid_t fsuid;
 kgid_t fsgid;
 unsigned securebits;
 kernel_cap_t cap_inheritable;
 kernel_cap_t cap_permitted;
 kernel_cap_t cap_effective;
 kernel_cap_t cap_bset;
# 151 "include/linux/cred.h"
 struct user_struct *user;
 struct user_namespace *user_ns;
 struct group_info *group_info;
 struct callback_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 const struct cred *get_task_cred(struct task_struct *);
extern struct cred *cred_alloc_blank(void);
extern struct cred *prepare_creds(void);
extern struct cred *prepare_exec_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);
# 204 "include/linux/cred.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void validate_creds(const struct cred *cred)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void validate_creds_for_do_exit(struct task_struct *tsk)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void validate_process_creds(void)
{
}
# 222 "include/linux/cred.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cred *get_new_cred(struct cred *cred)
{
 atomic_add(1, &cred->usage);
 return cred;
}
# 241 "include/linux/cred.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) const struct cred *get_cred(const struct cred *cred)
{
 struct cred *nonconst_cred = (struct cred *) cred;
 validate_creds(cred);
 return get_new_cred(nonconst_cred);
}
# 259 "include/linux/cred.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void put_cred(const struct cred *_cred)
{
 struct cred *cred = (struct cred *) _cred;

 validate_creds(cred);
 if ((atomic_sub_return(1, &(cred)->usage) == 0))
  __put_cred(cred);
}
# 368 "include/linux/cred.h"
extern struct user_namespace init_user_ns;
# 57 "include/linux/sched.h" 2



# 1 "./include/uapi/linux/magic.h" 1
# 61 "include/linux/sched.h" 2
# 110 "include/linux/sched.h"
struct sched_attr {
 u32 size;

 u32 sched_policy;
 u64 sched_flags;


 s32 sched_nice;


 u32 sched_priority;


 u64 sched_runtime;
 u64 sched_deadline;
 u64 sched_period;
};

struct exec_domain;
struct futex_pi_state;
struct robust_list_head;
struct bio_list;
struct fs_struct;
struct perf_event_context;
struct blk_plug;
struct filename;
# 151 "include/linux/sched.h"
extern unsigned long avenrun[];
extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
# 166 "include/linux/sched.h"
extern unsigned long total_forks;
extern int nr_threads;
extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) process_counts;
extern int nr_processes(void);
extern unsigned long nr_running(void);
extern bool single_task_running(void);
extern unsigned long nr_iowait(void);
extern unsigned long nr_iowait_cpu(int cpu);
extern void get_iowait_load(unsigned long *nr_waiters, unsigned long *load);

extern void calc_global_load(unsigned long ticks);
extern void update_cpu_load_nohz(void);

extern unsigned long get_parent_ip(unsigned long addr);

extern void dump_cpu_task(int cpu);

struct seq_file;
struct cfs_rq;
struct task_group;

extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
extern void proc_sched_set_task(struct task_struct *p);
extern void
print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
# 221 "include/linux/sched.h"
extern char ___assert_task_state[1 - 2*!!(
  sizeof("RSDTtXZxKWP")-1 != ( __builtin_constant_p(1024) ? ( (1024) < 1 ? ____ilog2_NaN() : (1024) & (1ULL << 63) ? 63 : (1024) & (1ULL << 62) ? 62 : (1024) & (1ULL << 61) ? 61 : (1024) & (1ULL << 60) ? 60 : (1024) & (1ULL << 59) ? 59 : (1024) & (1ULL << 58) ? 58 : (1024) & (1ULL << 57) ? 57 : (1024) & (1ULL << 56) ? 56 : (1024) & (1ULL << 55) ? 55 : (1024) & (1ULL << 54) ? 54 : (1024) & (1ULL << 53) ? 53 : (1024) & (1ULL << 52) ? 52 : (1024) & (1ULL << 51) ? 51 : (1024) & (1ULL << 50) ? 50 : (1024) & (1ULL << 49) ? 49 : (1024) & (1ULL << 48) ? 48 : (1024) & (1ULL << 47) ? 47 : (1024) & (1ULL << 46) ? 46 : (1024) & (1ULL << 45) ? 45 : (1024) & (1ULL << 44) ? 44 : (1024) & (1ULL << 43) ? 43 : (1024) & (1ULL << 42) ? 42 : (1024) & (1ULL << 41) ? 41 : (1024) & (1ULL << 40) ? 40 : (1024) & (1ULL << 39) ? 39 : (1024) & (1ULL << 38) ? 38 : (1024) & (1ULL << 37) ? 37 : (1024) & (1ULL << 36) ? 36 : (1024) & (1ULL << 35) ? 35 : (1024) & (1ULL << 34) ? 34 : (1024) & (1ULL << 33) ? 33 : (1024) & (1ULL << 32) ? 32 : (1024) & (1ULL << 31) ? 31 : (1024) & (1ULL << 30) ? 30 : (1024) & (1ULL << 29) ? 29 : (1024) & (1ULL << 28) ? 28 : (1024) & (1ULL << 27) ? 27 : (1024) & (1ULL << 26) ? 26 : (1024) & (1ULL << 25) ? 25 : (1024) & (1ULL << 24) ? 24 : (1024) & (1ULL << 23) ? 23 : (1024) & (1ULL << 22) ? 22 : (1024) & (1ULL << 21) ? 21 : (1024) & (1ULL << 20) ? 20 : (1024) & (1ULL << 19) ? 19 : (1024) & (1ULL << 18) ? 18 : (1024) & (1ULL << 17) ? 17 : (1024) & (1ULL << 16) ? 16 : (1024) & (1ULL << 15) ? 15 : (1024) & (1ULL << 14) ? 14 : (1024) & (1ULL << 13) ? 13 : (1024) & (1ULL << 12) ? 12 : (1024) & (1ULL << 11) ? 11 : (1024) & (1ULL << 10) ? 10 : (1024) & (1ULL << 9) ? 9 : (1024) & (1ULL << 8) ? 8 : (1024) & (1ULL << 7) ? 7 : (1024) & (1ULL << 6) ? 6 : (1024) & (1ULL << 5) ? 5 : (1024) & (1ULL << 4) ? 4 : (1024) & (1ULL << 3) ? 3 : (1024) & (1ULL << 2) ? 2 : (1024) & (1ULL << 1) ? 1 : (1024) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof(1024) <= 4) ? __ilog2_u32(1024) : __ilog2_u64(1024) )+1)];
# 317 "include/linux/sched.h"
extern rwlock_t tasklist_lock;
extern spinlock_t mmlist_lock;

struct task_struct;





extern void sched_init(void);
extern void sched_init_smp(void);
extern void schedule_tail(struct task_struct *prev);
extern void init_idle(struct task_struct *idle, int cpu);
extern void init_idle_bootup_task(struct task_struct *idle);

extern cpumask_var_t cpu_isolated_map;

extern int runqueue_is_locked(int cpu);


extern void nohz_balance_enter_idle(int cpu);
extern void set_cpu_sd_state_idle(void);
extern int get_nohz_timer_target(int pinned);
# 352 "include/linux/sched.h"
extern void show_state_filter(unsigned long state_filter);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);

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


extern void touch_softlockup_watchdog(void);
extern void touch_softlockup_watchdog_sync(void);
extern void touch_all_softlockup_watchdogs(void);
extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
      void *buffer,
      size_t *lenp, loff_t *ppos);
extern unsigned int softlockup_panic;
void lockup_detector_init(void);
# 400 "include/linux/sched.h"
void reset_hung_task_detector(void);
# 411 "include/linux/sched.h"
extern char __sched_text_start[], __sched_text_end[];


extern int in_sched_functions(unsigned long addr);


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

extern long io_schedule_timeout(long timeout);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void io_schedule(void)
{
 io_schedule_timeout(((long)(~0UL>>1)));
}

struct nsproxy;
struct user_namespace;


extern void arch_pick_mmap_layout(struct mm_struct *mm);
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);
# 457 "include/linux/sched.h"
extern void set_dumpable(struct mm_struct *mm, int value);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __get_dumpable(unsigned long mm_flags)
{
 return mm_flags & ((1 << 2) - 1);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_dumpable(struct mm_struct *mm)
{
 return __get_dumpable(mm->flags);
}
# 506 "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;
};
# 535 "include/linux/sched.h"
struct cputime {
 cputime_t utime;
 cputime_t stime;
};
# 554 "include/linux/sched.h"
struct task_cputime {
 cputime_t utime;
 cputime_t stime;
 unsigned long long sum_exec_runtime;
};
# 596 "include/linux/sched.h"
struct thread_group_cputimer {
 struct task_cputime cputime;
 int running;
 raw_spinlock_t lock;
};


struct autogroup;
# 612 "include/linux/sched.h"
struct signal_struct {
 atomic_t sigcnt;
 atomic_t live;
 int nr_threads;
 struct list_head thread_head;

 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;
# 649 "include/linux/sched.h"
 unsigned int is_child_subreaper:1;
 unsigned int has_child_subreaper:1;


 int posix_timer_id;
 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;
# 695 "include/linux/sched.h"
 seqlock_t stats_lock;
 cputime_t utime, stime, cutime, cstime;
 cputime_t gtime;
 cputime_t cgtime;

 struct cputime prev_cputime;

 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;
# 725 "include/linux/sched.h"
 struct rlimit rlim[16];
# 748 "include/linux/sched.h"
 struct rw_semaphore group_rwsem;


 oom_flags_t oom_flags;
 short oom_score_adj;
 short oom_score_adj_min;


 struct mutex cred_guard_mutex;


};
# 778 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int signal_group_exit(const struct signal_struct *sig)
{
 return (sig->flags & 0x00000004) ||
  (sig->group_exit_task != ((void *)0));
}




struct user_struct {
 atomic_t __count;
 atomic_t processes;
 atomic_t sigpending;

 atomic_t inotify_watches;
 atomic_t inotify_devs;





 atomic_long_t epoll_watches;





 unsigned long locked_shm;







 struct hlist_node uidhash_node;
 kuid_t uid;




};

extern int uids_sysfs_init(void);

extern struct user_struct *find_user(kuid_t);

extern struct user_struct root_user;



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






 return 0;

}

enum cpu_idle_type {
 CPU_IDLE,
 CPU_NOT_IDLE,
 CPU_NEWLY_IDLE,
 CPU_MAX_IDLE_TYPES
};
# 943 "include/linux/sched.h"
struct sched_domain_attr {
 int relax_domain_level;
};





extern int sched_domain_level_max;

struct sched_group;

struct sched_domain {

 struct sched_domain *parent;
 struct sched_domain *child;
 struct sched_group *groups;
 unsigned long min_interval;
 unsigned long max_interval;
 unsigned int busy_factor;
 unsigned int imbalance_pct;
 unsigned int cache_nice_tries;
 unsigned int busy_idx;
 unsigned int idle_idx;
 unsigned int newidle_idx;
 unsigned int wake_idx;
 unsigned int forkexec_idx;
 unsigned int smt_gain;

 int nohz_idle;
 int flags;
 int level;


 unsigned long last_balance;
 unsigned int balance_interval;
 unsigned int nr_balance_failed;


 u64 max_newidle_lb_cost;
 unsigned long next_decay_max_lb_cost;
# 1017 "include/linux/sched.h"
 char *name;

 union {
  void *private;
  struct callback_head rcu;
 };

 unsigned int span_weight;







 unsigned long span[0];
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cpumask *sched_domain_span(struct sched_domain *sd)
{
 return ((struct cpumask *)(1 ? (sd->span) : (void *)sizeof(__check_is_bitmap(sd->span))));
}

extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
        struct sched_domain_attr *dattr_new);


cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);

bool cpus_share_cache(int this_cpu, int that_cpu);

typedef const struct cpumask *(*sched_domain_mask_f)(int cpu);
typedef int (*sched_domain_flags_f)(void);



struct sd_data {
 struct sched_domain ** sd;
 struct sched_group ** sg;
 struct sched_group_capacity ** sgc;
};

struct sched_domain_topology_level {
 sched_domain_mask_f mask;
 sched_domain_flags_f sd_flags;
 int flags;
 int numa_level;
 struct sd_data data;

 char *name;

};

extern struct sched_domain_topology_level *sched_domain_topology;

extern void set_sched_topology(struct sched_domain_topology_level *tl);
extern void wake_up_if_idle(int cpu);
# 1100 "include/linux/sched.h"
struct io_context;





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


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

struct load_weight {
 unsigned long weight;
 u32 inv_weight;
};

struct sched_avg {





 u32 runnable_avg_sum, runnable_avg_period;
 u64 last_runnable_update;
 s64 decay_count;
 unsigned long load_avg_contrib;
};
# 1167 "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 nr_migrations;
# 1195 "include/linux/sched.h"
 struct sched_avg avg;

};

struct sched_rt_entity {
 struct list_head run_list;
 unsigned long timeout;
 unsigned long watchdog_stamp;
 unsigned int time_slice;

 struct sched_rt_entity *back;







};

struct sched_dl_entity {
 struct rb_node rb_node;






 u64 dl_runtime;
 u64 dl_deadline;
 u64 dl_period;
 u64 dl_bw;






 s64 runtime;
 u64 deadline;
 unsigned int flags;
# 1255 "include/linux/sched.h"
 int dl_throttled, dl_new, dl_boosted, dl_yielded;





 struct hrtimer dl_timer;
};

union rcu_special {
 struct {
  bool blocked;
  bool need_qs;
 } b;
 short s;
};
struct rcu_node;

enum perf_event_task_context {
 perf_invalid_context = -1,
 perf_hw_context = 0,
 perf_sw_context,
 perf_nr_task_contexts,
};

struct task_struct {
 volatile long state;
 void *stack;
 atomic_t usage;
 unsigned int flags;
 unsigned int ptrace;


 struct llist_node wake_entry;
 int on_cpu;
 struct task_struct *last_wakee;
 unsigned long wakee_flips;
 unsigned long wakee_flip_decay_ts;

 int wake_cpu;

 int on_rq;

 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;



 struct sched_dl_entity dl;
# 1317 "include/linux/sched.h"
 unsigned int policy;
 int nr_cpus_allowed;
 cpumask_t cpus_allowed;


 int rcu_read_lock_nesting;
 union rcu_special rcu_read_unlock_special;
 struct list_head rcu_node_entry;


 struct rcu_node *rcu_blocked_node;
# 1340 "include/linux/sched.h"
 struct list_head tasks;

 struct plist_node pushable_tasks;
 struct rb_node pushable_dl_tasks;


 struct mm_struct *mm, *active_mm;

 unsigned brk_randomized:1;


 u32 vmacache_seqnum;
 struct vm_area_struct *vmacache[(1U << 2)];

 struct task_rss_stat rss_stat;


 int exit_state;
 int exit_code, exit_signal;
 int pdeath_signal;
 unsigned int jobctl;


 unsigned int personality;

 unsigned in_execve:1;

 unsigned in_iowait:1;


 unsigned sched_reset_on_fork:1;
 unsigned sched_contributes_to_load:1;





 unsigned long atomic_flags;

 struct restart_block restart_block;

 pid_t pid;
 pid_t tgid;
# 1393 "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 pid_link pids[PIDTYPE_MAX];
 struct list_head thread_group;
 struct list_head thread_node;

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

 cputime_t utime, stime, utimescaled, stimescaled;
 cputime_t gtime;

 struct cputime prev_cputime;
# 1433 "include/linux/sched.h"
 unsigned long nvcsw, nivcsw;
 u64 start_time;
 u64 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;

 char comm[16];




 int link_count, total_link_count;


 struct sysv_sem sysvsem;
 struct sysv_shm sysvshm;



 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 callback_head *task_works;

 struct audit_context *audit_context;




 struct seccomp seccomp;


    u32 parent_exec_id;
    u32 self_exec_id;


 spinlock_t alloc_lock;


 raw_spinlock_t pi_lock;



 struct rb_root pi_waiters;
 struct rb_node *pi_waiters_leftmost;

 struct rt_mutex_waiter *pi_blocked_on;




 struct mutex_waiter *blocked_on;
# 1539 "include/linux/sched.h"
 void *journal_info;


 struct bio_list *bio_list;



 struct blk_plug *plug;



 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;
# 1572 "include/linux/sched.h"
 struct css_set *cgroups;

 struct list_head cg_list;


 struct robust_list_head *robust_list;



 struct list_head pi_state_list;
 struct futex_pi_state *pi_state_cache;







 unsigned long preempt_disable_ip;
# 1639 "include/linux/sched.h"
 struct callback_head rcu;




 struct pipe_inode_info *splice_pipe;

 struct page_frag task_frag;
# 1658 "include/linux/sched.h"
 int nr_dirtied;
 int nr_dirtied_pause;
 unsigned long dirty_paused_when;
# 1670 "include/linux/sched.h"
 unsigned long timer_slack_ns;
 unsigned long default_timer_slack_ns;
# 1715 "include/linux/sched.h"
};
# 1734 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_numa_fault(int last_node, int node, int pages,
       int flags)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pid_t task_numa_group_id(struct task_struct *p)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_numabalancing_state(bool enabled)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_numa_free(struct task_struct *p)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool should_numa_migrate_memory(struct task_struct *p,
    struct page *page, int src_nid, int dst_cpu)
{
 return true;
}


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

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






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

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

struct pid_namespace;
# 1795 "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)) __attribute__((no_instrument_function)) pid_t task_pid_nr(struct task_struct *tsk)
{
 return tsk->pid;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) pid_t task_pid_vnr(struct task_struct *tsk)
{
 return __task_pid_nr_ns(tsk, PIDTYPE_PID, ((void *)0));
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) pid_t task_tgid_vnr(struct task_struct *tsk)
{
 return pid_vnr(task_tgid(tsk));
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pid_alive(const struct task_struct *p);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
{
 pid_t pid = 0;

 rcu_read_lock();
 if (pid_alive(tsk))
  pid = task_tgid_nr_ns(({ typeof(*(tsk->real_parent)) *________p1 = (typeof(*(tsk->real_parent)) *)({ typeof((tsk->real_parent)) _________p1 = ({ union { typeof((tsk->real_parent)) __val; char __c[1]; } __u; __read_once_size(&((tsk->real_parent)), __u.__c, sizeof((tsk->real_parent))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(tsk->real_parent)) *)(________p1)); }), ns);
 rcu_read_unlock();

 return pid;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pid_t task_ppid_nr(const struct task_struct *tsk)
{
 return task_ppid_nr_ns(tsk, &init_pid_ns);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) pid_t task_pgrp_vnr(struct task_struct *tsk)
{
 return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ((void *)0));
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) pid_t task_session_vnr(struct task_struct *tsk)
{
 return __task_pid_nr_ns(tsk, PIDTYPE_SID, ((void *)0));
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pid_t task_pgrp_nr(struct task_struct *tsk)
{
 return task_pgrp_nr_ns(tsk, &init_pid_ns);
}
# 1885 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pid_alive(const struct task_struct *p)
{
 return p->pids[PIDTYPE_PID].pid != ((void *)0);
}
# 1898 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_global_init(struct task_struct *tsk)
{
 return tsk->pid == 1;
}

extern struct pid *cad_pid;

extern void free_task(struct task_struct *tsk);


extern void __put_task_struct(struct task_struct *t);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void put_task_struct(struct task_struct *t)
{
 if ((atomic_sub_return(1, &t->usage) == 0))
  __put_task_struct(t);
}
# 1923 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_cputime(struct task_struct *t,
    cputime_t *utime, cputime_t *stime)
{
 if (utime)
  *utime = t->utime;
 if (stime)
  *stime = t->stime;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_cputime_scaled(struct task_struct *t,
           cputime_t *utimescaled,
           cputime_t *stimescaled)
{
 if (utimescaled)
  *utimescaled = t->utimescaled;
 if (stimescaled)
  *stimescaled = t->stimescaled;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) cputime_t task_gtime(struct task_struct *t)
{
 return t->gtime;
}

extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
# 2009 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) gfp_t memalloc_noio_flags(gfp_t flags)
{
 if (__builtin_expect(!!((current_thread_info()->task)->flags & 0x00080000), 0))
  flags &= ~((( gfp_t)0x40u) | (( gfp_t)0x80u));
 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int memalloc_noio_save(void)
{
 unsigned int flags = (current_thread_info()->task)->flags & 0x00080000;
 (current_thread_info()->task)->flags |= 0x00080000;
 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void memalloc_noio_restore(unsigned int flags)
{
 (current_thread_info()->task)->flags = ((current_thread_info()->task)->flags & ~0x00080000) | flags;
}
# 2044 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool task_no_new_privs(struct task_struct *p) { return test_bit(0, &p->atomic_flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_set_no_new_privs(struct task_struct *p) { _set_bit(0,&p->atomic_flags); }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool task_spread_page(struct task_struct *p) { return test_bit(1, &p->atomic_flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_set_spread_page(struct task_struct *p) { _set_bit(1,&p->atomic_flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_clear_spread_page(struct task_struct *p) { _clear_bit(1,&p->atomic_flags); }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool task_spread_slab(struct task_struct *p) { return test_bit(2, &p->atomic_flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_set_spread_slab(struct task_struct *p) { _set_bit(2,&p->atomic_flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void task_clear_spread_slab(struct task_struct *p) { _clear_bit(2,&p->atomic_flags); }
# 2079 "include/linux/sched.h"
extern bool task_set_jobctl_pending(struct task_struct *task,
        unsigned int mask);
extern void task_clear_jobctl_trapping(struct task_struct *task);
extern void task_clear_jobctl_pending(struct task_struct *task,
          unsigned int mask);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void rcu_copy_process(struct task_struct *p)
{

 p->rcu_read_lock_nesting = 0;
 p->rcu_read_unlock_special.s = 0;
 p->rcu_blocked_node = ((void *)0);
 INIT_LIST_HEAD(&p->rcu_node_entry);






}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void tsk_restore_flags(struct task_struct *task,
    unsigned long orig_flags, unsigned long flags)
{
 task->flags &= ~flags;
 task->flags |= orig_flags & flags;
}

extern int cpuset_cpumask_can_shrink(const struct cpumask *cur,
         const struct cpumask *trial);
extern int task_can_attach(struct task_struct *p,
      const struct cpumask *cs_cpus_allowed);

extern void do_set_cpus_allowed(struct task_struct *p,
          const struct cpumask *new_mask);

extern int set_cpus_allowed_ptr(struct task_struct *p,
    const struct cpumask *new_mask);
# 2132 "include/linux/sched.h"
void calc_load_enter_idle(void);
void calc_load_exit_idle(void);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
{
 return set_cpus_allowed_ptr(p, &new_mask);
}
# 2154 "include/linux/sched.h"
extern unsigned long long __attribute__((no_instrument_function)) sched_clock(void);



extern u64 cpu_clock(int cpu);
extern u64 local_clock(void);
extern u64 running_clock(void);
extern u64 sched_clock_cpu(int cpu);


extern void sched_clock_init(void);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_clock_tick(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_clock_idle_sleep_event(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_clock_idle_wakeup_event(u64 delta_ns)
{
}
# 2203 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void enable_sched_clock_irqtime(void) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void disable_sched_clock_irqtime(void) {}


extern unsigned long long
task_sched_runtime(struct task_struct *task);



extern void sched_exec(void);




extern void sched_clock_idle_sleep_event(void);
extern void sched_clock_idle_wakeup_event(u64 delta_ns);


extern void idle_task_exit(void);





extern void wake_up_nohz_cpu(int cpu);
# 2236 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool sched_can_stop_tick(void) { return false; }
# 2249 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_autogroup_create_attach(struct task_struct *p) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_autogroup_detach(struct task_struct *p) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_autogroup_fork(struct signal_struct *sig) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sched_autogroup_exit(struct signal_struct *sig) { }


extern int yield_to(struct task_struct *p, bool preempt);
extern void set_user_nice(struct task_struct *p, long nice);
extern int task_prio(const struct task_struct *p);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int task_nice(const struct task_struct *p)
{
 return (((p)->static_prio) - (100 + (19 - -20 + 1) / 2));
}
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,
         const struct sched_param *);
extern int sched_setscheduler_nocheck(struct task_struct *, int,
          const struct sched_param *);
extern int sched_setattr(struct task_struct *,
    const struct sched_attr *);
extern struct task_struct *idle_task(int cpu);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool is_idle_task(const struct task_struct *p)
{
 return p->pid == 0;
}
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[(((1UL) << 12) << 1)/sizeof(long)];
};


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



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


extern union thread_union init_thread_union;
extern struct task_struct init_task;

extern struct mm_struct init_mm;

extern struct pid_namespace init_pid_ns;
# 2331 "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 struct user_struct * alloc_uid(kuid_t);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct user_struct *get_uid(struct user_struct *u)
{
 atomic_add(1, &u->__count);
 return u;
}
extern void free_uid(struct user_struct *);

# 1 "arch/arm/include/generated/asm/current.h" 1
# 2345 "include/linux/sched.h" 2

extern void xtime_update(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);

 extern void kick_process(struct task_struct *tsk);



extern int sched_fork(unsigned long clone_flags, struct task_struct *p);
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)) __attribute__((no_instrument_function)) int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
 unsigned long flags;
 int ret;

 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&tsk->sighand->siglock)); } while (0); } while (0);
 ret = dequeue_signal(tsk, mask, info);
 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);

 return ret;
}

extern void block_all_signals(int (*notifier)(void *priv), void *priv,
         sigset_t *mask);
extern void unblock_all_signals(void);
extern void release_task(struct task_struct * p);
extern int send_sig_info(int, struct siginfo *, struct task_struct *);
extern int 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_cred(int, struct siginfo *, struct pid *,
    const struct cred *, 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 __attribute__((warn_unused_result)) bool 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 int send_sig(int, struct task_struct *, int);
extern int 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 *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void restore_saved_sigmask(void)
{
 if (test_and_clear_restore_sigmask())
  __set_current_blocked(&(current_thread_info()->task)->saved_sigmask);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) sigset_t *sigmask_to_save(void)
{
 sigset_t *res = &(current_thread_info()->task)->blocked;
 if (__builtin_expect(!!(test_restore_sigmask()), 0))
  res = &(current_thread_info()->task)->saved_sigmask;
 return res;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kill_cad_pid(int sig, int priv)
{
 return kill_pid(cad_pid, sig, priv);
}
# 2429 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int on_sig_stack(unsigned long sp)
{




 return sp > (current_thread_info()->task)->sas_ss_sp &&
  sp - (current_thread_info()->task)->sas_ss_sp <= (current_thread_info()->task)->sas_ss_size;

}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int sas_ss_flags(unsigned long sp)
{
 if (!(current_thread_info()->task)->sas_ss_size)
  return 2;

 return on_sig_stack(sp) ? 1 : 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
{
 if (__builtin_expect(!!((ksig->ka.sa.sa_flags & 0x08000000)), 0) && ! sas_ss_flags(sp))



  return (current_thread_info()->task)->sas_ss_sp + (current_thread_info()->task)->sas_ss_size;

 return sp;
}




extern struct mm_struct * mm_alloc(void);


extern void __mmdrop(struct mm_struct *);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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 struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);

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

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

extern void exit_files(struct task_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 int do_execve(struct filename *,
       const char * const *,
       const char * const *);
extern int do_execveat(int, struct filename *,
         const char * const *,
         const char * const *,
         int);
extern long do_fork(unsigned long, unsigned long, unsigned long, int *, int *);
struct task_struct *fork_idle(int);
extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);

extern void __set_task_comm(struct task_struct *tsk, const char *from, bool exec);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_task_comm(struct task_struct *tsk, const char *from)
{
 __set_task_comm(tsk, from, false);
}
extern char *get_task_comm(char *to, struct task_struct *tsk);


void scheduler_ipi(void);
extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
# 2534 "include/linux/sched.h"
extern bool current_is_single_threaded(void);
# 2556 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_nr_threads(struct task_struct *tsk)
{
 return tsk->signal->nr_threads;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool thread_group_leader(struct task_struct *p)
{
 return p->exit_signal >= 0;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool has_group_leader_pid(struct task_struct *p)
{
 return task_pid(p) == p->signal->leader_pid;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function))
bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
{
 return p1->signal == p2->signal;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct task_struct *next_thread(const struct task_struct *p)
{
 return ({ typeof(*p->thread_group.next) *__ptr = (typeof(*p->thread_group.next) *)p->thread_group.next; ({ const typeof( ((struct task_struct *)0)->thread_group ) *__mptr = ((typeof(p->thread_group.next))({ typeof(*(__ptr)) *________p1 = (typeof(*(__ptr)) *)({ typeof((__ptr)) _________p1 = ({ union { typeof((__ptr)) __val; char __c[1]; } __u; __read_once_size(&((__ptr)), __u.__c, sizeof((__ptr))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(__ptr)) *)(________p1)); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,thread_group) );}); })
                                          ;
}

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
             unsigned long *flags)
{
 struct sighand_struct *ret;

 ret = __lock_task_sighand(tsk, flags);
 (void)(ret);
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void unlock_task_sighand(struct task_struct *tsk,
      unsigned long *flags)
{
 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void threadgroup_change_begin(struct task_struct *tsk)
{
 down_read(&tsk->signal->group_rwsem);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void threadgroup_change_end(struct task_struct *tsk)
{
 up_read(&tsk->signal->group_rwsem);
}
# 2662 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void threadgroup_lock(struct task_struct *tsk)
{
 down_write(&tsk->signal->group_rwsem);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void threadgroup_unlock(struct task_struct *tsk)
{
 up_write(&tsk->signal->group_rwsem);
}
# 2689 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}
# 2704 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long *end_of_stack(struct task_struct *p)
{



 return (unsigned long *)(((struct thread_info *)(p)->stack) + 1);

}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int object_is_on_stack(void *obj)
{
 void *stack = (((current_thread_info()->task))->stack);

 return (obj >= stack) && (obj < (stack + (((1UL) << 12) << 1)));
}

extern void thread_info_cache_init(void);
# 2738 "include/linux/sched.h"
extern void set_task_stack_end_magic(struct task_struct *tsk);




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void set_tsk_need_resched(struct task_struct *tsk)
{
 set_tsk_thread_flag(tsk,1);
}

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int test_tsk_need_resched(struct task_struct *tsk)
{
 return __builtin_expect(!!(test_tsk_thread_flag(tsk,1)), 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int restart_syscall(void)
{
 set_tsk_thread_flag((current_thread_info()->task), 0);
 return -513;
}

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __fatal_signal_pending(struct task_struct *p)
{
 return __builtin_expect(!!(sigismember(&p->pending.signal, 9)), 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int fatal_signal_pending(struct task_struct *p)
{
 return signal_pending(p) && __fatal_signal_pending(p);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
}
# 2821 "include/linux/sched.h"
extern int _cond_resched(void);






extern int __cond_resched_lock(spinlock_t *lock);
# 2841 "include/linux/sched.h"
extern int __cond_resched_softirq(void);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void cond_resched_rcu(void)
{





}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int spin_needbreak(spinlock_t *lock)
{

 return spin_is_contended(lock);



}
# 2918 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int tsk_is_polling(struct task_struct *p) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __current_set_polling(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __current_clr_polling(void) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool __attribute__((warn_unused_result)) current_set_polling_and_test(void)
{
 return __builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 1)), 0);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool __attribute__((warn_unused_result)) current_clr_polling_and_test(void)
{
 return __builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 1)), 0);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void current_clr_polling(void)
{
 __current_clr_polling();







 __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 do { if (test_ti_thread_flag(current_thread_info(), 1)) set_preempt_need_resched(); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) bool need_resched(void)
{
 return __builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 1)), 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)) __attribute__((no_instrument_function)) void thread_group_cputime_init(struct signal_struct *sig)
{
 do { static struct lock_class_key __key; __raw_spin_lock_init((&sig->cputimer.lock), "&sig->cputimer.lock", &__key); } while (0);
}







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

extern void signal_wake_up_state(struct task_struct *t, unsigned int state);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void signal_wake_up(struct task_struct *t, bool resume)
{
 signal_wake_up_state(t, resume ? 128 : 0);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ptrace_signal_wake_up(struct task_struct *t, bool resume)
{
 signal_wake_up_state(t, resume ? 8 : 0);
}






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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int task_node(const struct task_struct *p)
{
 return ((void)(task_cpu(p)),0);
}

extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
# 3013 "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 int task_can_switch_user(struct user_struct *up,
     struct task_struct *tsk);
# 3044 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void add_rchar(struct task_struct *tsk, ssize_t amt)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void add_wchar(struct task_struct *tsk, ssize_t amt)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void inc_syscr(struct task_struct *tsk)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void inc_syscw(struct task_struct *tsk)
{
}
# 3068 "include/linux/sched.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mm_update_next_owner(struct mm_struct *mm)
{
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long task_rlimit(const struct task_struct *tsk,
  unsigned int limit)
{
 return (*({ __attribute__((unused)) typeof(tsk->signal->rlim[limit].rlim_cur) __var = ( typeof(tsk->signal->rlim[limit].rlim_cur)) 0; (volatile typeof(tsk->signal->rlim[limit].rlim_cur) *)&(tsk->signal->rlim[limit].rlim_cur); }));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long task_rlimit_max(const struct task_struct *tsk,
  unsigned int limit)
{
 return (*({ __attribute__((unused)) typeof(tsk->signal->rlim[limit].rlim_max) __var = ( typeof(tsk->signal->rlim[limit].rlim_max)) 0; (volatile typeof(tsk->signal->rlim[limit].rlim_max) *)&(tsk->signal->rlim[limit].rlim_max); }));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long rlimit(unsigned int limit)
{
 return task_rlimit((current_thread_info()->task), limit);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long rlimit_max(unsigned int limit)
{
 return task_rlimit_max((current_thread_info()->task), limit);
}
# 205 "./arch/arm/include/asm/tlbflush.h" 2

struct cpu_tlb_fns {
 void (*flush_user_range)(unsigned long, unsigned long, struct vm_area_struct *);
 void (*flush_kern_range)(unsigned long, unsigned long);
 unsigned long tlb_flags;
};
# 230 "./arch/arm/include/asm/tlbflush.h"
extern struct cpu_tlb_fns cpu_tlb;
# 322 "./arch/arm/include/asm/tlbflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __local_flush_tlb_all(void)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 9) | (1 << 12))) asm("mcr " "p15, 0, %0, " "c8, c7, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 9) | (1 << 12))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 9) | (1 << 12)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 10) | (1 << 13))) asm("mcr " "p15, 0, %0, " "c8, c6, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 10) | (1 << 13))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 10) | (1 << 13)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11) | (1 << 14))) asm("mcr " "p15, 0, %0, " "c8, c5, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11) | (1 << 14))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 11) | (1 << 14)) : "cc"); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_flush_tlb_all(void)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "nshst" : : : "memory");

 __local_flush_tlb_all();
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 21))) asm("mcr " "p15, 0, %0, " "c8, c7, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 21))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 21)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))))) {
  __asm__ __volatile__ ("dsb " "nsh" : : : "memory");
  __asm__ __volatile__ ("isb " "" : : : "memory");
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __flush_tlb_all(void)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "ishst" : : : "memory");

 __local_flush_tlb_all();
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 21))) asm("mcr " "p15, 0, %0, " "c8, c3, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 21))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c3, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 21)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))))) {
  __asm__ __volatile__ ("dsb " "ish" : : : "memory");
  __asm__ __volatile__ ("isb " "" : : : "memory");
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __local_flush_tlb_mm(struct mm_struct *mm)
{
 const int zero = 0;
 const int asid = ((unsigned int)((mm)->context.id.counter & ~((~0ULL) << 8)));
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 9)|(1 << 10)|(1 << 11))) {
  if (test_bit(cpumask_check(debug_smp_processor_id()), (((mm_cpumask(mm)))->bits))) {
   do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 9))) asm("mcr " "p15, 0, %0, " "c8, c7, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 9))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 9)) : "cc"); } while (0);
   do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 10))) asm("mcr " "p15, 0, %0, " "c8, c6, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 10))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 10)) : "cc"); } while (0);
   do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11))) asm("mcr " "p15, 0, %0, " "c8, c5, 0" : : "r" (zero) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 0" : : "r" (zero), "r" (__tlb_flag), "Ir" ((1 << 11)) : "cc"); } while (0);
  }
 }

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 16))) asm("mcr " "p15, 0, %0, " "c8, c7, 2" : : "r" (asid) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 16))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 2" : : "r" (asid), "r" (__tlb_flag), "Ir" ((1 << 16)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 17))) asm("mcr " "p15, 0, %0, " "c8, c6, 2" : : "r" (asid) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 17))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 2" : : "r" (asid), "r" (__tlb_flag), "Ir" ((1 << 17)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 18))) asm("mcr " "p15, 0, %0, " "c8, c5, 2" : : "r" (asid) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 18))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 2" : : "r" (asid), "r" (__tlb_flag), "Ir" ((1 << 18)) : "cc"); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_flush_tlb_mm(struct mm_struct *mm)
{
 const int asid = ((unsigned int)((mm)->context.id.counter & ~((~0ULL) << 8)));
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "nshst" : : : "memory");

 __local_flush_tlb_mm(mm);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 22))) asm("mcr " "p15, 0, %0, " "c8, c7, 2" : : "r" (asid) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 22))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 2" : : "r" (asid), "r" (__tlb_flag), "Ir" ((1 << 22)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28)))))
  __asm__ __volatile__ ("dsb " "nsh" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __flush_tlb_mm(struct mm_struct *mm)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "ishst" : : : "memory");

 __local_flush_tlb_mm(mm);



 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 22))) asm("mcr " "p15, 0, %0, " "c8, c3, 2" : : "r" (((unsigned int)((mm)->context.id.counter & ~((~0ULL) << 8)))) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 22))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c3, 2" : : "r" (((unsigned int)((mm)->context.id.counter & ~((~0ULL) << 8)))), "r" (__tlb_flag), "Ir" ((1 << 22)) : "cc"); } while (0);


 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28)))))
  __asm__ __volatile__ ("dsb " "ish" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
__local_flush_tlb_page(struct vm_area_struct *vma, unsigned long uaddr)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 uaddr = (uaddr & (~((1 << 12) - 1))) | ((unsigned int)((vma->vm_mm)->context.id.counter & ~((~0ULL) << 8)));

 if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 1)|(1 << 2)|(1 << 3)|(1 << 11)) &&
     test_bit(cpumask_check(debug_smp_processor_id()), (((mm_cpumask(vma->vm_mm)))->bits))) {
  do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 1))) asm("mcr " "p15, 0, %0, " "c8, c7, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 1))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 1)) : "cc"); } while (0);
  do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 2))) asm("mcr " "p15, 0, %0, " "c8, c6, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 2))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 2)) : "cc"); } while (0);
  do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3))) asm("mcr " "p15, 0, %0, " "c8, c5, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 3)) : "cc"); } while (0);
  if (!((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3)))) && ((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11)))))
   asm("mcr p15, 0, %0, c8, c5, 0" : : "r" (zero) : "cc");
 }

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 4))) asm("mcr " "p15, 0, %0, " "c8, c7, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 4))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 4)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 5))) asm("mcr " "p15, 0, %0, " "c8, c6, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 5))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 5)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 6))) asm("mcr " "p15, 0, %0, " "c8, c5, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 6))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 6)) : "cc"); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
local_flush_tlb_page(struct vm_area_struct *vma, unsigned long uaddr)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 uaddr = (uaddr & (~((1 << 12) - 1))) | ((unsigned int)((vma->vm_mm)->context.id.counter & ~((~0ULL) << 8)));

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "nshst" : : : "memory");

 __local_flush_tlb_page(vma, uaddr);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("mcr " "p15, 0, %0, " "c8, c7, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 20)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28)))))
  __asm__ __volatile__ ("dsb " "nsh" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
__flush_tlb_page(struct vm_area_struct *vma, unsigned long uaddr)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 uaddr = (uaddr & (~((1 << 12) - 1))) | ((unsigned int)((vma->vm_mm)->context.id.counter & ~((~0ULL) << 8)));

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "ishst" : : : "memory");

 __local_flush_tlb_page(vma, uaddr);



 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("mcr " "p15, 0, %0, " "c8, c3, 1" : : "r" (uaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c3, 1" : : "r" (uaddr), "r" (__tlb_flag), "Ir" ((1 << 20)) : "cc"); } while (0);


 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28)))))
  __asm__ __volatile__ ("dsb " "ish" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __local_flush_tlb_kernel_page(unsigned long kaddr)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 1))) asm("mcr " "p15, 0, %0, " "c8, c7, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 1))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 1)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 2))) asm("mcr " "p15, 0, %0, " "c8, c6, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 2))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 2)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3))) asm("mcr " "p15, 0, %0, " "c8, c5, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 3)) : "cc"); } while (0);
 if (!((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 3)))) && ((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 11)))))
  asm("mcr p15, 0, %0, c8, c5, 0" : : "r" (zero) : "cc");

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 4))) asm("mcr " "p15, 0, %0, " "c8, c7, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 4))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 4)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 5))) asm("mcr " "p15, 0, %0, " "c8, c6, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 5))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c6, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 5)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 6))) asm("mcr " "p15, 0, %0, " "c8, c5, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 6))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c5, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 6)) : "cc"); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_flush_tlb_kernel_page(unsigned long kaddr)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 kaddr &= (~((1 << 12) - 1));

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "nshst" : : : "memory");

 __local_flush_tlb_kernel_page(kaddr);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("mcr " "p15, 0, %0, " "c8, c7, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c7, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 20)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))))) {
  __asm__ __volatile__ ("dsb " "nsh" : : : "memory");
  __asm__ __volatile__ ("isb " "" : : : "memory");
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __flush_tlb_kernel_page(unsigned long kaddr)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 kaddr &= (~((1 << 12) - 1));

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "ishst" : : : "memory");

 __local_flush_tlb_kernel_page(kaddr);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("mcr " "p15, 0, %0, " "c8, c3, 1" : : "r" (kaddr) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 20))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c8, c3, 1" : : "r" (kaddr), "r" (__tlb_flag), "Ir" ((1 << 20)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 28))))) {
  __asm__ __volatile__ ("dsb " "ish" : : : "memory");
  __asm__ __volatile__ ("isb " "" : : : "memory");
 }
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __local_flush_bp_all(void)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 19))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 19)))))
  asm("mcr p15, 0, %0, c7, c5, 6" : : "r" (zero));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void local_flush_bp_all(void)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 __local_flush_bp_all();
 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 23))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 23)))))
  asm("mcr p15, 0, %0, c7, c5, 6" : : "r" (zero));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __flush_bp_all(void)
{
 const int zero = 0;
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 __local_flush_bp_all();
 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 23))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 23)))))
  asm("mcr p15, 0, %0, c7, c1, 6" : : "r" (zero));
}
# 576 "./arch/arm/include/asm/tlbflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void flush_pmd_entry(void *pmd)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 30))) asm("mcr " "p15, 0, %0, " "c7, c10, 1	@ flush_pmd" : : "r" (pmd) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 30))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c7, c10, 1	@ flush_pmd" : : "r" (pmd), "r" (__tlb_flag), "Ir" ((1 << 30)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 29))) asm("mcr " "p15, 1, %0, " "c15, c9, 1  @ L2 flush_pmd" : : "r" (pmd) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 29))) asm("tst %1, %2\n\t" "mcrne " "p15, 1, %0, " "c15, c9, 1  @ L2 flush_pmd" : : "r" (pmd), "r" (__tlb_flag), "Ir" ((1 << 29)) : "cc"); } while (0);

 if (((((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31))) || (__tlb_flag & (0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 31)))))
  __asm__ __volatile__ ("dsb " "ishst" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void clean_pmd_entry(void *pmd)
{
 const unsigned int __tlb_flag = cpu_tlb.tlb_flags;

 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 30))) asm("mcr " "p15, 0, %0, " "c7, c10, 1	@ flush_pmd" : : "r" (pmd) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 30))) asm("tst %1, %2\n\t" "mcrne " "p15, 0, %0, " "c7, c10, 1	@ flush_pmd" : : "r" (pmd), "r" (__tlb_flag), "Ir" ((1 << 30)) : "cc"); } while (0);
 do { if (((-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (-1UL) & (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) & ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 29))) asm("mcr " "p15, 1, %0, " "c15, c9, 1  @ L2 flush_pmd" : : "r" (pmd) : "cc"); else if ((0 | 0 | 0 | 0 | 0 | 0 | (((1 << 31) | (1 << 28) | (1 << 21) | (1 << 20) | (1 << 22) | (1 << 23)) | ((1 << 31) | (1 << 30) | (1 << 28) | (1 << 12) | (1 << 4) | (1 << 16) | (1 << 19)))) & ((1 << 29))) asm("tst %1, %2\n\t" "mcrne " "p15, 1, %0, " "c15, c9, 1  @ L2 flush_pmd" : : "r" (pmd), "r" (__tlb_flag), "Ir" ((1 << 29)) : "cc"); } while (0);
}
# 615 "./arch/arm/include/asm/tlbflush.h"
extern void flush_tlb_all(void);
extern void flush_tlb_mm(struct mm_struct *mm);
extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long uaddr);
extern void flush_tlb_kernel_page(unsigned long kaddr);
extern void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned long end);
extern void flush_tlb_kernel_range(unsigned long start, unsigned long end);
extern void flush_bp_all(void);
# 634 "./arch/arm/include/asm/tlbflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void update_mmu_cache(struct vm_area_struct *vma,
        unsigned long addr, pte_t *ptep)
{
}
# 673 "./arch/arm/include/asm/tlbflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void erratum_a15_798181_init(void) {}

extern bool (*erratum_a15_798181_handler)(void);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool erratum_a15_798181(void)
{
 if (__builtin_expect(!!((0 || 0) && erratum_a15_798181_handler), 0)
                             )
  return erratum_a15_798181_handler();
 return false;
}
# 29 "./arch/arm/include/asm/pgtable.h" 2




# 1 "./arch/arm/include/asm/pgtable-2level.h" 1
# 160 "./arch/arm/include/asm/pgtable-2level.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pmd_t *pmd_offset(pud_t *pud, unsigned long addr)
{
 return (pmd_t *)pud;
}
# 187 "./arch/arm/include/asm/pgtable-2level.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkspecial(pte_t pte) { return pte; }
# 34 "./arch/arm/include/asm/pgtable.h" 2
# 51 "./arch/arm/include/asm/pgtable.h"
extern void __pte_error(const char *file, int line, pte_t);
extern void __pmd_error(const char *file, int line, pmd_t);
extern void __pgd_error(const char *file, int line, pgd_t);
# 83 "./arch/arm/include/asm/pgtable.h"
extern pgprot_t pgprot_user;
extern pgprot_t pgprot_kernel;
extern pgprot_t pgprot_hyp_device;
extern pgprot_t pgprot_s2;
extern pgprot_t pgprot_s2_device;
# 129 "./arch/arm/include/asm/pgtable.h"
struct file;
extern pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
         unsigned long size, pgprot_t vma_prot);
# 170 "./arch/arm/include/asm/pgtable.h"
extern struct page *empty_zero_page;



extern pgd_t swapper_pg_dir[2048];
# 187 "./arch/arm/include/asm/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t *pmd_page_vaddr(pmd_t pmd)
{
 return ((void *)__phys_to_virt((phys_addr_t)((pmd) & (~0UL) & (s32)(~((1 << 12) - 1)))));
}
# 238 "./arch/arm/include/asm/pgtable.h"
extern void __sync_icache_dcache(pte_t pteval);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_pte_at(struct mm_struct *mm, unsigned long addr,
         pte_t *ptep, pte_t pteval)
{
 unsigned long ext = 0;

 if (addr < ((0xC0000000UL) - (0x01000000UL)) && ((((u32)((((pteval_t)(1)) << 0)) == ((((pteval_t)(1)) << 0)) ? ((pteval)) & ((((pteval_t)(1)) << 0)) : !!(((pteval)) & ((((pteval_t)(1)) << 0))))) && ((u32)((((pteval_t)(1)) << 8)) == ((((pteval_t)(1)) << 8)) ? ((pteval)) & ((((pteval_t)(1)) << 8)) : !!(((pteval)) & ((((pteval_t)(1)) << 8)))) && (((u32)((((pteval_t)(1)) << 1)) == ((((pteval_t)(1)) << 1)) ? ((pteval)) & ((((pteval_t)(1)) << 1)) : !!(((pteval)) & ((((pteval_t)(1)) << 1))))))) {
  if (!(0))
   __sync_icache_dcache(pteval);
  ext |= (((pteval_t)(1)) << 11);
 }

 processor.set_pte_ext(ptep,pteval,ext);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t clear_pte_bit(pte_t pte, pgprot_t prot)
{
 (pte) &= ~(prot);
 return pte;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t set_pte_bit(pte_t pte, pgprot_t prot)
{
 (pte) |= (prot);
 return pte;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_wrprotect(pte_t pte)
{
 return set_pte_bit(pte, ((((pteval_t)(1)) << 7)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkwrite(pte_t pte)
{
 return clear_pte_bit(pte, ((((pteval_t)(1)) << 7)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkclean(pte_t pte)
{
 return clear_pte_bit(pte, ((((pteval_t)(1)) << 6)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkdirty(pte_t pte)
{
 return set_pte_bit(pte, ((((pteval_t)(1)) << 6)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkold(pte_t pte)
{
 return clear_pte_bit(pte, ((((pteval_t)(1)) << 1)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkyoung(pte_t pte)
{
 return set_pte_bit(pte, ((((pteval_t)(1)) << 1)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mkexec(pte_t pte)
{
 return clear_pte_bit(pte, ((((pteval_t)(1)) << 9)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mknexec(pte_t pte)
{
 return set_pte_bit(pte, ((((pteval_t)(1)) << 9)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_modify(pte_t pte, pgprot_t newprot)
{
 const pteval_t mask = (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 7) | (((pteval_t)(1)) << 8) |
  (((pteval_t)(1)) << 11) | (((pteval_t)(1)) << 0);
 (pte) = ((pte) & ~mask) | ((newprot) & mask);
 return pte;
}
# 349 "./arch/arm/include/asm/pgtable.h"
# 1 "include/asm-generic/pgtable.h" 1
# 27 "include/asm-generic/pgtable.h"
extern int ptep_set_access_flags(struct vm_area_struct *vma,
     unsigned long address, pte_t *ptep,
     pte_t entry, int dirty);



extern int pmdp_set_access_flags(struct vm_area_struct *vma,
     unsigned long address, pmd_t *pmdp,
     pmd_t entry, int dirty);



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ptep_test_and_clear_young(struct vm_area_struct *vma,
         unsigned long address,
         pte_t *ptep)
{
 pte_t pte = *ptep;
 int r = 1;
 if (!(((u32)((((pteval_t)(1)) << 1)) == ((((pteval_t)(1)) << 1)) ? ((pte)) & ((((pteval_t)(1)) << 1)) : !!(((pte)) & ((((pteval_t)(1)) << 1))))))
  r = 0;
 else
  set_pte_at(vma->vm_mm, address, ptep, pte_mkold(pte));
 return r;
}
# 68 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmdp_test_and_clear_young(struct vm_area_struct *vma,
         unsigned long address,
         pmd_t *pmdp)
{
 do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/asm-generic/pgtable.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "72" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
 return 0;
}




int ptep_clear_flush_young(struct vm_area_struct *vma,
      unsigned long address, pte_t *ptep);



int pmdp_clear_flush_young(struct vm_area_struct *vma,
      unsigned long address, pmd_t *pmdp);



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t ptep_get_and_clear(struct mm_struct *mm,
           unsigned long address,
           pte_t *ptep)
{
 pte_t pte = *ptep;
 processor.set_pte_ext(ptep,(0),0);
 return pte;
}
# 124 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t ptep_get_and_clear_full(struct mm_struct *mm,
         unsigned long address, pte_t *ptep,
         int full)
{
 pte_t pte;
 pte = ptep_get_and_clear(mm, address, ptep);
 return pte;
}
# 140 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pte_clear_not_present_full(struct mm_struct *mm,
           unsigned long address,
           pte_t *ptep,
           int full)
{
 processor.set_pte_ext(ptep,(0),0);
}



extern pte_t ptep_clear_flush(struct vm_area_struct *vma,
         unsigned long address,
         pte_t *ptep);



extern pmd_t pmdp_clear_flush(struct vm_area_struct *vma,
         unsigned long address,
         pmd_t *pmdp);



struct mm_struct;
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ptep_set_wrprotect(struct mm_struct *mm, unsigned long address, pte_t *ptep)
{
 pte_t old_pte = *ptep;
 set_pte_at(mm, address, ptep, pte_wrprotect(old_pte));
}
# 179 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pmdp_set_wrprotect(struct mm_struct *mm,
          unsigned long address, pmd_t *pmdp)
{
 do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/asm-generic/pgtable.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "182" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
}




extern void pmdp_splitting_flush(struct vm_area_struct *vma,
     unsigned long address, pmd_t *pmdp);



extern void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
           pgtable_t pgtable);



extern pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp);



extern void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
       pmd_t *pmdp);



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pte_same(pte_t pte_a, pte_t pte_b)
{
 return (pte_a) == (pte_b);
}
# 220 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pte_unused(pte_t pte)
{
 return 0;
}
# 233 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_same(pmd_t pmd_a, pmd_t pmd_b)
{
 do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/asm-generic/pgtable.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "235" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
 return 0;
}
# 271 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
{
 if ((oldprot) == ((((oldprot) & ~((((pteval_t)(0x0f)) << 2))) | ((((pteval_t)(0x00)) << 2)))))
  newprot = (((newprot) & ~((((pteval_t)(0x0f)) << 2))) | ((((pteval_t)(0x00)) << 2)));
 if ((oldprot) == ((((oldprot) & ~((((pteval_t)(0x0f)) << 2))) | ((((pteval_t)(0x01)) << 2)))))
  newprot = (((newprot) & ~((((pteval_t)(0x0f)) << 2))) | ((((pteval_t)(0x01)) << 2)));
 if ((oldprot) == ((((oldprot) & ~((((pteval_t)(0x0f)) << 2))) | ((((pteval_t)(0x00)) << 2)))))
  newprot = (((newprot) & ~((((pteval_t)(0x0f)) << 2))) | ((((pteval_t)(0x00)) << 2)));
 return newprot;
}
# 313 "include/asm-generic/pgtable.h"
void pgd_clear_bad(pgd_t *);
void pud_clear_bad(pud_t *);
void pmd_clear_bad(pmd_t *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pgd_none_or_clear_bad(pgd_t *pgd)
{
 if (pgd_none(*pgd))
  return 1;
 if (__builtin_expect(!!(pgd_bad(*pgd)), 0)) {
  pgd_clear_bad(pgd);
  return 1;
 }
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pud_none_or_clear_bad(pud_t *pud)
{
 if ((0))
  return 1;
 if (__builtin_expect(!!((0)), 0)) {
  pud_clear_bad(pud);
  return 1;
 }
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_none_or_clear_bad(pmd_t *pmd)
{
 if ((!(*pmd)))
  return 1;
 if (__builtin_expect(!!(((*pmd) & 2)), 0)) {
  pmd_clear_bad(pmd);
  return 1;
 }
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t __ptep_modify_prot_start(struct mm_struct *mm,
          unsigned long addr,
          pte_t *ptep)
{





 return ptep_get_and_clear(mm, addr, ptep);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ptep_modify_prot_commit(struct mm_struct *mm,
          unsigned long addr,
          pte_t *ptep, pte_t pte)
{




 set_pte_at(mm, addr, ptep, pte);
}
# 388 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t ptep_modify_prot_start(struct mm_struct *mm,
        unsigned long addr,
        pte_t *ptep)
{
 return __ptep_modify_prot_start(mm, addr, ptep);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ptep_modify_prot_commit(struct mm_struct *mm,
        unsigned long addr,
        pte_t *ptep, pte_t pte)
{
 __ptep_modify_prot_commit(mm, addr, ptep, pte);
}
# 445 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pte_soft_dirty(pte_t pte)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_soft_dirty(pmd_t pmd)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_mksoft_dirty(pte_t pte)
{
 return pte;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pmd_t pmd_mksoft_dirty(pmd_t pmd)
{
 return pmd;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_swp_mksoft_dirty(pte_t pte)
{
 return pte;
}

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t pte_swp_clear_soft_dirty(pte_t pte)
{
 return pte;
}
# 492 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int track_pfn_remap(struct vm_area_struct *vma, pgprot_t *prot,
      unsigned long pfn, unsigned long addr,
      unsigned long size)
{
 return 0;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int track_pfn_insert(struct vm_area_struct *vma, pgprot_t *prot,
       unsigned long pfn)
{
 return 0;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int track_pfn_copy(struct vm_area_struct *vma)
{
 return 0;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void untrack_pfn(struct vm_area_struct *vma,
          unsigned long pfn, unsigned long size)
{
}
# 549 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_zero_pfn(unsigned long pfn)
{
 extern unsigned long zero_pfn;
 return pfn == zero_pfn;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long my_zero_pfn(unsigned long addr)
{
 extern unsigned long zero_pfn;
 return zero_pfn;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_trans_huge(pmd_t pmd)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_trans_splitting(pmd_t pmd)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_write(pmd_t pmd)
{
 do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/asm-generic/pgtable.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "576" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
 return 0;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pmd_t pmd_read_atomic(pmd_t *pmdp)
{





 return *pmdp;
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_move_must_withdraw(spinlock_t *new_pmd_ptl,
      spinlock_t *old_pmd_ptl)
{




 return new_pmd_ptl != old_pmd_ptl;
}
# 627 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_none_or_trans_huge_or_clear_bad(pmd_t *pmd)
{
 pmd_t pmdval = pmd_read_atomic(pmd);
# 647 "include/asm-generic/pgtable.h"
 if ((!(pmdval)) || pmd_trans_huge(pmdval))
  return 1;
 if (__builtin_expect(!!(((pmdval) & 2)), 0)) {
  pmd_clear_bad(pmd);
  return 1;
 }
 return 0;
}
# 669 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_trans_unstable(pmd_t *pmd)
{



 return 0;

}
# 687 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pte_protnone(pte_t pte)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_protnone(pmd_t pmd)
{
 return 0;
}
# 706 "include/asm-generic/pgtable.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pud_clear_huge(pud_t *pud)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_clear_huge(pmd_t *pmd)
{
 return 0;
}
# 350 "./arch/arm/include/asm/pgtable.h" 2
# 54 "include/linux/mm.h" 2
# 71 "include/linux/mm.h"
extern unsigned long sysctl_user_reserve_kbytes;
extern unsigned long sysctl_admin_reserve_kbytes;

extern int sysctl_overcommit_memory;
extern int sysctl_overcommit_ratio;
extern unsigned long sysctl_overcommit_kbytes;

extern int overcommit_ratio_handler(struct ctl_table *, int, void *,
        size_t *, loff_t *);
extern int overcommit_kbytes_handler(struct ctl_table *, int, void *,
        size_t *, loff_t *);
# 100 "include/linux/mm.h"
extern struct kmem_cache *vm_area_cachep;
# 205 "include/linux/mm.h"
extern pgprot_t protection_map[16];
# 222 "include/linux/mm.h"
struct vm_fault {
 unsigned int flags;
 unsigned long pgoff;
 void *virtual_address;

 struct page *cow_page;
 struct page *page;





 unsigned long max_pgoff;

 pte_t *pte;
};






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);
 void (*map_pages)(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);




 const char *(*name)(struct vm_area_struct *vma);
# 293 "include/linux/mm.h"
 struct page *(*find_special_page)(struct vm_area_struct *vma,
       unsigned long addr);
};

struct mmu_gather;
struct inode;





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_freepage_migratetype(struct page *page, int migratetype)
{
 page->index = migratetype;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_freepage_migratetype(struct page *page)
{
 return page->index;
}





# 1 "include/linux/page-flags.h" 1
# 74 "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_swapbacked,
 PG_unevictable,

 PG_mlocked,
# 112 "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_foreign = PG_owner_priv_1,


 PG_slob_free = PG_private,
};
# 228 "include/linux/page-flags.h"
struct page;
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageCompound(struct page *page);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageTail(struct page *page);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *compound_head_by_tail(struct page *tail)
{
 struct page *head = tail->first_page;






 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 if (__builtin_expect(!!(PageTail(tail)), 1))
  return head;
 return tail;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *compound_head(struct page *page)
{
 if (__builtin_expect(!!(PageTail(page)), 0))
  return compound_head_by_tail(page);
 return page;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *compound_head_fast(struct page *page)
{
 if (__builtin_expect(!!(PageTail(page)), 0))
  return page->first_page;
 return page;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageLocked(struct page *page) { return test_bit(PG_locked, &({ if (0) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageLocked(struct page *page) { __set_bit(PG_locked, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageLocked(struct page *page) { __clear_bit(PG_locked, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageError(struct page *page) { return test_bit(PG_error, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageError(struct page *page) { _set_bit(PG_error,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageError(struct page *page) { _clear_bit(PG_error,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageError(struct page *page) { return _test_and_clear_bit(PG_error,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageReferenced(struct page *page) { return test_bit(PG_referenced, &compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageReferenced(struct page *page) { _set_bit(PG_referenced,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageReferenced(struct page *page) { _clear_bit(PG_referenced,&compound_head(page)->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageReferenced(struct page *page) { return _test_and_clear_bit(PG_referenced,&compound_head(page)->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageReferenced(struct page *page) { __set_bit(PG_referenced, &compound_head(page)->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageDirty(struct page *page) { return test_bit(PG_dirty, &compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageDirty(struct page *page) { _set_bit(PG_dirty,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageDirty(struct page *page) { _clear_bit(PG_dirty,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestSetPageDirty(struct page *page) { return _test_and_set_bit(PG_dirty,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageDirty(struct page *page) { return _test_and_clear_bit(PG_dirty,&compound_head(page)->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageDirty(struct page *page) { __clear_bit(PG_dirty, &compound_head(page)->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageLRU(struct page *page) { return test_bit(PG_lru, &compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageLRU(struct page *page) { _set_bit(PG_lru,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageLRU(struct page *page) { _clear_bit(PG_lru,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageLRU(struct page *page) { __clear_bit(PG_lru, &compound_head(page)->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageActive(struct page *page) { return test_bit(PG_active, &compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageActive(struct page *page) { _set_bit(PG_active,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageActive(struct page *page) { _clear_bit(PG_active,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageActive(struct page *page) { __clear_bit(PG_active, &compound_head(page)->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageActive(struct page *page) { return _test_and_clear_bit(PG_active,&compound_head(page)->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageSlab(struct page *page) { return test_bit(PG_slab, &({ if (0) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageSlab(struct page *page) { __set_bit(PG_slab, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageSlab(struct page *page) { __clear_bit(PG_slab, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageSlobFree(struct page *page) { return test_bit(PG_slob_free, &({ if (0) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageSlobFree(struct page *page) { __set_bit(PG_slob_free, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageSlobFree(struct page *page) { __clear_bit(PG_slob_free, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageChecked(struct page *page) { return test_bit(PG_checked, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageChecked(struct page *page) { _set_bit(PG_checked,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageChecked(struct page *page) { _clear_bit(PG_checked,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PagePinned(struct page *page) { return test_bit(PG_pinned, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPagePinned(struct page *page) { _set_bit(PG_pinned,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPagePinned(struct page *page) { _clear_bit(PG_pinned,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestSetPagePinned(struct page *page) { return _test_and_set_bit(PG_pinned,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPagePinned(struct page *page) { return _test_and_clear_bit(PG_pinned,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageSavePinned(struct page *page) { return test_bit(PG_savepinned, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageSavePinned(struct page *page) { _set_bit(PG_savepinned,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageSavePinned(struct page *page) { _clear_bit(PG_savepinned,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageForeign(struct page *page) { return test_bit(PG_foreign, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageForeign(struct page *page) { _set_bit(PG_foreign,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageForeign(struct page *page) { _clear_bit(PG_foreign,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageReserved(struct page *page) { return test_bit(PG_reserved, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageReserved(struct page *page) { _set_bit(PG_reserved,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageReserved(struct page *page) { _clear_bit(PG_reserved,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageReserved(struct page *page) { __clear_bit(PG_reserved, &({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageSwapBacked(struct page *page) { return test_bit(PG_swapbacked, &({ if (0) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageSwapBacked(struct page *page) { _set_bit(PG_swapbacked,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageSwapBacked(struct page *page) { _clear_bit(PG_swapbacked,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageSwapBacked(struct page *page) { __clear_bit(PG_swapbacked, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageSwapBacked(struct page *page) { __set_bit(PG_swapbacked, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PagePrivate(struct page *page) { return test_bit(PG_private, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPagePrivate(struct page *page) { _set_bit(PG_private,&page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPagePrivate(struct page *page) { _clear_bit(PG_private,&page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPagePrivate(struct page *page) { __set_bit(PG_private, &page->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPagePrivate(struct page *page) { __clear_bit(PG_private, &page->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PagePrivate2(struct page *page) { return test_bit(PG_private_2, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPagePrivate2(struct page *page) { _set_bit(PG_private_2,&page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPagePrivate2(struct page *page) { _clear_bit(PG_private_2,&page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestSetPagePrivate2(struct page *page) { return _test_and_set_bit(PG_private_2,&page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPagePrivate2(struct page *page) { return _test_and_clear_bit(PG_private_2,&page->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageOwnerPriv1(struct page *page) { return test_bit(PG_owner_priv_1, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageOwnerPriv1(struct page *page) { _set_bit(PG_owner_priv_1,&page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageOwnerPriv1(struct page *page) { _clear_bit(PG_owner_priv_1,&page->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageOwnerPriv1(struct page *page) { return _test_and_clear_bit(PG_owner_priv_1,&page->flags); }





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageWriteback(struct page *page) { return test_bit(PG_writeback, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestSetPageWriteback(struct page *page) { return _test_and_set_bit(PG_writeback,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageWriteback(struct page *page) { return _test_and_clear_bit(PG_writeback,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageMappedToDisk(struct page *page) { return test_bit(PG_mappedtodisk, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageMappedToDisk(struct page *page) { _set_bit(PG_mappedtodisk,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageMappedToDisk(struct page *page) { _clear_bit(PG_mappedtodisk,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageReclaim(struct page *page) { return test_bit(PG_reclaim, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageReclaim(struct page *page) { _set_bit(PG_reclaim,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageReclaim(struct page *page) { _clear_bit(PG_reclaim,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageReclaim(struct page *page) { return _test_and_clear_bit(PG_reclaim,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageReadahead(struct page *page) { return test_bit(PG_reclaim, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageReadahead(struct page *page) { _set_bit(PG_reclaim,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageReadahead(struct page *page) { _clear_bit(PG_reclaim,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageReadahead(struct page *page) { return _test_and_clear_bit(PG_reclaim,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }
# 333 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageSwapCache(struct page *page) { return test_bit(PG_swapcache, &({ if (0) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageSwapCache(struct page *page) { _set_bit(PG_swapcache,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageSwapCache(struct page *page) { _clear_bit(PG_swapcache,&({ if (1) ((void)(sizeof(( long)(PageCompound(page))))); page;})->flags); }




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageUnevictable(struct page *page) { return test_bit(PG_unevictable, &compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageUnevictable(struct page *page) { _set_bit(PG_unevictable,&compound_head(page)->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageUnevictable(struct page *page) { _clear_bit(PG_unevictable,&compound_head(page)->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageUnevictable(struct page *page) { __clear_bit(PG_unevictable, &compound_head(page)->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageUnevictable(struct page *page) { return _test_and_clear_bit(PG_unevictable,&compound_head(page)->flags); }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageMlocked(struct page *page) { return test_bit(PG_mlocked, &({ if (0) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageMlocked(struct page *page) { _set_bit(PG_mlocked,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageMlocked(struct page *page) { _clear_bit(PG_mlocked,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageMlocked(struct page *page) { __clear_bit(PG_mlocked, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestSetPageMlocked(struct page *page) { return _test_and_set_bit(PG_mlocked,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int TestClearPageMlocked(struct page *page) { return _test_and_clear_bit(PG_mlocked,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
 static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __TestClearPageMlocked(struct page *page) { return __test_and_clear_bit(PG_mlocked, &({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }
# 354 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageUncached(const struct page *page) { return 0; } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageUncached(struct page *page) { } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageUncached(struct page *page) { }







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageHWPoison(const struct page *page) { return 0; } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageHWPoison(struct page *page) { } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageHWPoison(struct page *page) { }
# 386 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageAnon(struct page *page)
{
 page = compound_head(page);
 return ((unsigned long)page->mapping & 1) != 0;
}
# 406 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageKsm(const struct page *page) { return 0; }


u64 stable_page_flags(struct page *page);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageUptodate(struct page *page)
{
 int ret;
 page = compound_head(page);
 ret = test_bit(PG_uptodate, &(page)->flags);
# 424 "include/linux/page-flags.h"
 if (ret)
  __asm__ __volatile__ ("dmb " "ish" : : : "memory");

 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageUptodate(struct page *page)
{
 ((void)(sizeof(( long)(PageTail(page)))));
 __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
 __set_bit(PG_uptodate, &page->flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageUptodate(struct page *page)
{
 ((void)(sizeof(( long)(PageTail(page)))));





 __asm__ __volatile__ ("dmb " "ishst" : : : "memory");
 _set_bit(PG_uptodate,&page->flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageUptodate(struct page *page) { _clear_bit(PG_uptodate,&({ if (1) ((void)(sizeof(( long)(PageTail(page))))); else page = compound_head(page); page;})->flags); }

int test_clear_page_writeback(struct page *page);
int __test_set_page_writeback(struct page *page, bool keep_write);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_page_writeback(struct page *page)
{
 __test_set_page_writeback(page, false);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_page_writeback_keepwrite(struct page *page)
{
 __test_set_page_writeback(page, true);
}
# 478 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageHead(struct page *page) { return test_bit(PG_head, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageHead(struct page *page) { __set_bit(PG_head, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageHead(struct page *page) { __clear_bit(PG_head, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageHead(struct page *page) { _clear_bit(PG_head,&page->flags); }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageTail(struct page *page) { return test_bit(PG_tail, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageTail(struct page *page) { __set_bit(PG_tail, &page->flags); } static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageTail(struct page *page) { __clear_bit(PG_tail, &page->flags); }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageCompound(struct page *page)
{
 return page->flags & ((1L << PG_head) | (1L << PG_tail));

}
# 553 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageHuge(const struct page *page) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageHeadHuge(const struct page *page) { return 0; }
# 593 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageTransHuge(const struct page *page) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageTransCompound(const struct page *page) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageTransTail(const struct page *page) { return 0; }
# 609 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageBuddy(struct page *page)
{
 return (*({ __attribute__((unused)) typeof((&page->_mapcount)->counter) __var = ( typeof((&page->_mapcount)->counter)) 0; (volatile typeof((&page->_mapcount)->counter) *)&((&page->_mapcount)->counter); })) == (-128);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageBuddy(struct page *page)
{
 ((void)(sizeof(( long)((*({ __attribute__((unused)) typeof((&page->_mapcount)->counter) __var = ( typeof((&page->_mapcount)->counter)) 0; (volatile typeof((&page->_mapcount)->counter) *)&((&page->_mapcount)->counter); })) != -1))));
 (((&page->_mapcount)->counter) = ((-128)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageBuddy(struct page *page)
{
 ((void)(sizeof(( long)(!PageBuddy(page)))));
 (((&page->_mapcount)->counter) = (-1));
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageBalloon(struct page *page)
{
 return (*({ __attribute__((unused)) typeof((&page->_mapcount)->counter) __var = ( typeof((&page->_mapcount)->counter)) 0; (volatile typeof((&page->_mapcount)->counter) *)&((&page->_mapcount)->counter); })) == (-256);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __SetPageBalloon(struct page *page)
{
 ((void)(sizeof(( long)((*({ __attribute__((unused)) typeof((&page->_mapcount)->counter) __var = ( typeof((&page->_mapcount)->counter)) 0; (volatile typeof((&page->_mapcount)->counter) *)&((&page->_mapcount)->counter); })) != -1))));
 (((&page->_mapcount)->counter) = ((-256)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageBalloon(struct page *page)
{
 ((void)(sizeof(( long)(!PageBalloon(page)))));
 (((&page->_mapcount)->counter) = (-1));
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int PageSlabPfmemalloc(struct page *page)
{
 ((void)(sizeof(( long)(!PageSlab(page)))));
 return PageActive(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void SetPageSlabPfmemalloc(struct page *page)
{
 ((void)(sizeof(( long)(!PageSlab(page)))));
 SetPageActive(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __ClearPageSlabPfmemalloc(struct page *page)
{
 ((void)(sizeof(( long)(!PageSlab(page)))));
 __ClearPageActive(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ClearPageSlabPfmemalloc(struct page *page)
{
 ((void)(sizeof(( long)(!PageSlab(page)))));
 ClearPageActive(page);
}
# 713 "include/linux/page-flags.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_has_private(struct page *page)
{
 return !!(page->flags & (1 << PG_private | 1 << PG_private_2));
}
# 320 "include/linux/mm.h" 2
# 1 "include/linux/huge_mm.h" 1



extern int do_huge_pmd_anonymous_page(struct mm_struct *mm,
          struct vm_area_struct *vma,
          unsigned long address, pmd_t *pmd,
          unsigned int flags);
extern int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
    pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr,
    struct vm_area_struct *vma);
extern void huge_pmd_set_accessed(struct mm_struct *mm,
      struct vm_area_struct *vma,
      unsigned long address, pmd_t *pmd,
      pmd_t orig_pmd, int dirty);
extern int do_huge_pmd_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,
          unsigned long address, pmd_t *pmd,
          pmd_t orig_pmd);
extern struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
       unsigned long addr,
       pmd_t *pmd,
       unsigned int flags);
extern int madvise_free_huge_pmd(struct mmu_gather *tlb,
   struct vm_area_struct *vma,
   pmd_t *pmd, unsigned long addr);
extern int zap_huge_pmd(struct mmu_gather *tlb,
   struct vm_area_struct *vma,
   pmd_t *pmd, unsigned long addr);
extern int mincore_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
   unsigned long addr, unsigned long end,
   unsigned char *vec);
extern int move_huge_pmd(struct vm_area_struct *vma,
    struct vm_area_struct *new_vma,
    unsigned long old_addr,
    unsigned long new_addr, unsigned long old_end,
    pmd_t *old_pmd, pmd_t *new_pmd);
extern int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
   unsigned long addr, pgprot_t newprot,
   int prot_numa);

enum transparent_hugepage_flag {
 TRANSPARENT_HUGEPAGE_FLAG,
 TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG,
 TRANSPARENT_HUGEPAGE_DEFRAG_FLAG,
 TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG,
 TRANSPARENT_HUGEPAGE_DEFRAG_KHUGEPAGED_FLAG,
 TRANSPARENT_HUGEPAGE_USE_ZERO_PAGE_FLAG,



};

enum page_check_address_pmd_flag {
 PAGE_CHECK_ADDRESS_PMD_FLAG,
 PAGE_CHECK_ADDRESS_PMD_NOTSPLITTING_FLAG,
 PAGE_CHECK_ADDRESS_PMD_SPLITTING_FLAG,
};
extern pmd_t *page_check_address_pmd(struct page *page,
         struct mm_struct *mm,
         unsigned long address,
         enum page_check_address_pmd_flag flag,
         spinlock_t **ptl);
extern int pmd_freeable(pmd_t pmd);
# 181 "include/linux/huge_mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
split_huge_page_to_list(struct page *page, struct list_head *list)
{
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int split_huge_page(struct page *page)
{
 return 0;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int hugepage_madvise(struct vm_area_struct *vma,
       unsigned long *vm_flags, int advice)
{
 do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/huge_mm.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "199" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
 return 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vma_adjust_trans_huge(struct vm_area_struct *vma,
      unsigned long start,
      unsigned long end,
      long adjust_next)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int pmd_trans_huge_lock(pmd_t *pmd, struct vm_area_struct *vma,
  spinlock_t **ptl)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
     unsigned long addr, pmd_t pmd, pmd_t *pmdp)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool is_huge_zero_page(struct page *page)
{
 return false;
}
# 321 "include/linux/mm.h" 2
# 338 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int put_page_testzero(struct page *page)
{
 ((void)(sizeof(( long)((*({ __attribute__((unused)) typeof((&page->_count)->counter) __var = ( typeof((&page->_count)->counter)) 0; (volatile typeof((&page->_count)->counter) *)&((&page->_count)->counter); })) == 0))));
 return (atomic_sub_return(1, &page->_count) == 0);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_page_unless_zero(struct page *page)
{
 return atomic_add_unless((&page->_count), 1, 0);
}
# 362 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int put_page_unless_one(struct page *page)
{
 return atomic_add_unless(&page->_count, -1, 1);
}

extern int page_is_ram(unsigned long pfn);
extern int region_is_ram(resource_size_t phys_addr, unsigned long size);


struct page *vmalloc_to_page(const void *addr);
unsigned long vmalloc_to_pfn(const void *addr);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_vmalloc_addr(const void *x)
{

 unsigned long addr = (unsigned long)x;

 return addr >= (((unsigned long)high_memory + (8*1024*1024)) & ~((8*1024*1024)-1)) && addr < 0xff000000UL;



}

extern int is_vmalloc_or_module_addr(const void *x);







extern void kvfree(const void *addr);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void compound_lock(struct page *page)
{




}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void compound_unlock(struct page *page)
{




}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long compound_lock_irqsave(struct page *page)
{
 unsigned long flags = flags;




 return flags;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void compound_unlock_irqrestore(struct page *page,
           unsigned long flags)
{




}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void page_mapcount_reset(struct page *page)
{
 (((&(page)->_mapcount)->counter) = (-1));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_mapcount(struct page *page)
{
 ((void)(sizeof(( long)(PageSlab(page)))));
 return (*({ __attribute__((unused)) typeof((&page->_mapcount)->counter) __var = ( typeof((&page->_mapcount)->counter)) 0; (volatile typeof((&page->_mapcount)->counter) *)&((&page->_mapcount)->counter); })) + 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_count(struct page *page)
{
 return (*({ __attribute__((unused)) typeof((&compound_head(page)->_count)->counter) __var = ( typeof((&compound_head(page)->_count)->counter)) 0; (volatile typeof((&compound_head(page)->_count)->counter) *)&((&compound_head(page)->_count)->counter); }));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool __compound_tail_refcounted(struct page *page)
{
 return !PageSlab(page) && !PageHeadHuge(page);
}
# 470 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool compound_tail_refcounted(struct page *page)
{
 ((void)(sizeof(( long)(!PageHead(page)))));
 return __compound_tail_refcounted(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void get_huge_page_tail(struct page *page)
{



 ((void)(sizeof(( long)(!PageTail(page)))));
 ((void)(sizeof(( long)(page_mapcount(page) < 0))));
 ((void)(sizeof(( long)((*({ __attribute__((unused)) typeof((&page->_count)->counter) __var = ( typeof((&page->_count)->counter)) 0; (volatile typeof((&page->_count)->counter) *)&((&page->_count)->counter); })) != 0))));
 if (compound_tail_refcounted(page->first_page))
  atomic_add(1, &page->_mapcount);
}

extern bool __get_page_tail(struct page *page);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void get_page(struct page *page)
{
 if (__builtin_expect(!!(PageTail(page)), 0))
  if (__builtin_expect(!!(__get_page_tail(page)), 1))
   return;




 ((void)(sizeof(( long)((*({ __attribute__((unused)) typeof((&page->_count)->counter) __var = ( typeof((&page->_count)->counter)) 0; (volatile typeof((&page->_count)->counter) *)&((&page->_count)->counter); })) <= 0))));
 atomic_add(1, &page->_count);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *virt_to_head_page(const void *x)
{
 struct page *page = (mem_map + ((((((unsigned long)(x) - (0xC0000000UL)) >> 12) + (__pv_phys_pfn_offset))) - (__pv_phys_pfn_offset)));







 return compound_head_fast(page);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
int split_free_page(struct page *page);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_compound_page_dtor(struct page *page,
      compound_page_dtor *dtor)
{
 page[1].compound_dtor = dtor;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) compound_page_dtor *get_compound_page_dtor(struct page *page)
{
 return page[1].compound_dtor;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int compound_order(struct page *page)
{
 if (!PageHead(page))
  return 0;
 return page[1].compound_order;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_compound_order(struct page *page, unsigned long order)
{
 page[1].compound_order = order;
}
# 567 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
{
 if (__builtin_expect(!!(vma->vm_flags & 0x00000002), 1))
  pte = pte_mkwrite(pte);
 return pte;
}

void do_set_pte(struct vm_area_struct *vma, unsigned long address,
  struct page *page, pte_t *pte, bool write, bool anon);
# 682 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) enum zone_type page_zonenum(const struct page *page)
{
 return (page->flags >> (((((sizeof(unsigned long)*8) - 0) - 0) - 2) * (2 != 0))) & ((1UL << 2) - 1);
}
# 699 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int zone_to_nid(struct zone *zone)
{



 return 0;

}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_to_nid(const struct page *page)
{
 return (page->flags >> ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0))) & ((1UL << 0) - 1);
}
# 790 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_cpupid_xchg_last(struct page *page, int cpupid)
{
 return page_to_nid(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_cpupid_last(struct page *page)
{
 return page_to_nid(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpupid_to_nid(int cpupid)
{
 return -1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpupid_to_pid(int cpupid)
{
 return -1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpupid_to_cpu(int cpupid)
{
 return -1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cpu_pid_to_cpupid(int nid, int pid)
{
 return -1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cpupid_pid_unset(int cpupid)
{
 return 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void page_cpupid_reset_last(struct page *page)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cpupid_match_pid(struct task_struct *task, int cpupid)
{
 return false;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct zone *page_zone(const struct page *page)
{
 return &(&contig_page_data)->node_zones[page_zonenum(page)];
}
# 853 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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);



}




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





# 1 "include/linux/mm.h" 1
# 7 "include/linux/vmstat.h" 2

# 1 "include/linux/vm_event_item.h" 1
# 24 "include/linux/vm_event_item.h"
enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
  PGALLOC_NORMAL , PGALLOC_HIGH , PGALLOC_MOVABLE,
  PGFREE, PGACTIVATE, PGDEACTIVATE,
  PGFAULT, PGMAJFAULT,
  PGLAZYFREED,
  PGREFILL_NORMAL , PGREFILL_HIGH , PGREFILL_MOVABLE,
  PGSTEAL_KSWAPD_NORMAL , PGSTEAL_KSWAPD_HIGH , PGSTEAL_KSWAPD_MOVABLE,
  PGSTEAL_DIRECT_NORMAL , PGSTEAL_DIRECT_HIGH , PGSTEAL_DIRECT_MOVABLE,
  PGSCAN_KSWAPD_NORMAL , PGSCAN_KSWAPD_HIGH , PGSCAN_KSWAPD_MOVABLE,
  PGSCAN_DIRECT_NORMAL , PGSCAN_DIRECT_HIGH , PGSCAN_DIRECT_MOVABLE,
  PGSCAN_DIRECT_THROTTLE,



  PGINODESTEAL, SLABS_SCANNED, KSWAPD_INODESTEAL,
  KSWAPD_LOW_WMARK_HIT_QUICKLY, KSWAPD_HIGH_WMARK_HIT_QUICKLY,
  PAGEOUTRUN, ALLOCSTALL, PGROTATED,
  DROP_PAGECACHE, DROP_SLAB,
# 50 "include/linux/vm_event_item.h"
  PGMIGRATE_SUCCESS, PGMIGRATE_FAIL,


  COMPACTMIGRATE_SCANNED, COMPACTFREE_SCANNED,
  COMPACTISOLATED,
  COMPACTSTALL, COMPACTFAIL, COMPACTSUCCESS,




  UNEVICTABLE_PGCULLED,
  UNEVICTABLE_PGSCANNED,
  UNEVICTABLE_PGRESCUED,
  UNEVICTABLE_PGMLOCKED,
  UNEVICTABLE_PGMUNLOCKED,
  UNEVICTABLE_PGCLEARED,
  UNEVICTABLE_PGSTRANDED,
# 96 "include/linux/vm_event_item.h"
  NR_VM_EVENT_ITEMS
};
# 9 "include/linux/vmstat.h" 2


extern int sysctl_stat_interval;
# 24 "include/linux/vmstat.h"
struct vm_event_state {
 unsigned long event[NR_VM_EVENT_ITEMS];
};

extern __attribute__((section(".data..percpu" ""))) __typeof__(struct vm_event_state) vm_event_states;





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __count_vm_event(enum vm_event_item item)
{
 do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void count_vm_event(enum vm_event_item item)
{
 do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 2: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 4: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 8: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __count_vm_events(enum vm_event_item item, long delta)
{
 do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void count_vm_events(enum vm_event_item item, long delta)
{
 do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 2: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 4: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 8: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))); (typeof((typeof(*(&(vm_event_states.event[item]))) *)(&(vm_event_states.event[item])))) (__ptr + ((__my_cpu_offset()))); }); }) += delta; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
}

extern void all_vm_events(unsigned long *);

extern void vm_events_fold_cpu(int cpu);
# 111 "include/linux/vmstat.h"
extern atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) unsigned long global_page_state(enum zone_stat_item item)
{
 long x = atomic_long_read(&vm_stat[item]);

 if (x < 0)
  x = 0;

 return x;
}

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

 if (x < 0)
  x = 0;

 return x;
}







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


 int cpu;
 for (((cpu)) = -1; ((cpu)) = cpumask_next(((cpu)), (cpu_online_mask)), ((cpu)) < nr_cpu_ids;)
  x += ({ do { const void *__vpp_verify = (typeof((zone->pageset) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((zone->pageset))) *)((zone->pageset)))); (typeof((typeof(*((zone->pageset))) *)((zone->pageset)))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })->vm_stat_diff[item];

 if (x < 0)
  x = 0;

 return x;
}
# 201 "include/linux/vmstat.h"
void __mod_zone_page_state(struct zone *, enum zone_stat_item item, int);
void __inc_zone_page_state(struct page *, enum zone_stat_item);
void __dec_zone_page_state(struct page *, enum zone_stat_item);

void mod_zone_page_state(struct zone *, enum zone_stat_item, int);
void inc_zone_page_state(struct page *, enum zone_stat_item);
void dec_zone_page_state(struct page *, enum zone_stat_item);

extern void inc_zone_state(struct zone *, enum zone_stat_item);
extern void __inc_zone_state(struct zone *, enum zone_stat_item);
extern void dec_zone_state(struct zone *, enum zone_stat_item);
extern void __dec_zone_state(struct zone *, enum zone_stat_item);

void cpu_vm_stats_fold(int cpu);
void refresh_zone_stat_thresholds(void);

void drain_zonestat(struct zone *zone, struct per_cpu_pageset *);

int calculate_pressure_threshold(struct zone *zone);
int calculate_normal_threshold(struct zone *zone);
void set_pgdat_percpu_threshold(pg_data_t *pgdat,
    int (*calculate_pressure)(struct zone *));
# 280 "include/linux/vmstat.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __mod_zone_freepage_state(struct zone *zone, int nr_pages,
          int migratetype)
{
 __mod_zone_page_state(zone, NR_FREE_PAGES, nr_pages);
 if (__builtin_expect(!!((migratetype) == MIGRATE_CMA), 0))
  __mod_zone_page_state(zone, NR_FREE_CMA_PAGES, nr_pages);
}

extern const char * const vmstat_text[];
# 879 "include/linux/mm.h" 2

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *lowmem_page_address(const struct page *page)
{
 return ((void *)__phys_to_virt((phys_addr_t)(((phys_addr_t)(((unsigned long)((page) - mem_map) + (__pv_phys_pfn_offset))) << 12))));
}
# 902 "include/linux/mm.h"
void *page_address(const struct page *page);
void set_page_address(struct page *page, void *virtual);
void page_address_init(void);
# 913 "include/linux/mm.h"
extern struct address_space *page_mapping(struct page *page);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *page_rmapping(struct page *page)
{
 page = compound_head(page);
 return (void *)((unsigned long)page->mapping & ~(1 | 2));
}

extern struct address_space *__page_file_mapping(struct page *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function))
struct address_space *page_file_mapping(struct page *page)
{
 if (__builtin_expect(!!(PageSwapCache(page)), 0))
  return __page_file_mapping(page);

 return page->mapping;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long page_index(struct page *page)
{
 if (__builtin_expect(!!(PageSwapCache(page)), 0))
  return ((page)->private);
 return page->index;
}

extern unsigned long __page_file_index(struct page *page);





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long page_file_index(struct page *page)
{
 if (__builtin_expect(!!(PageSwapCache(page)), 0))
  return __page_file_index(page);

 return page->index;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_mapped(struct page *page)
{
 return (*({ __attribute__((unused)) typeof((&(page)->_mapcount)->counter) __var = ( typeof((&(page)->_mapcount)->counter)) 0; (volatile typeof((&(page)->_mapcount)->counter) *)&((&(page)->_mapcount)->counter); })) >= 0;
}
# 1000 "include/linux/mm.h"
extern void pagefault_out_of_memory(void);
# 1010 "include/linux/mm.h"
extern void show_free_areas(unsigned int flags);
extern bool skip_free_areas_node(unsigned int flags, int nid);

int shmem_zero_setup(struct vm_area_struct *);

bool shmem_mapping(struct address_space *mapping);







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 address_space *check_mapping;
 unsigned long first_index;
 unsigned long last_index;
};

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);
void zap_page_range(struct vm_area_struct *vma, unsigned long address,
  unsigned long size, struct zap_details *);
void unmap_vmas(struct mmu_gather *tlb, struct vm_area_struct *start_vma,
  unsigned long start, unsigned long end);
# 1066 "include/linux/mm.h"
struct mm_walk {
 int (*pmd_entry)(pmd_t *pmd, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*pte_entry)(pte_t *pte, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*pte_hole)(unsigned long addr, unsigned long next,
   struct mm_walk *walk);
 int (*hugetlb_entry)(pte_t *pte, unsigned long hmask,
        unsigned long addr, unsigned long next,
        struct mm_walk *walk);
 int (*test_walk)(unsigned long addr, unsigned long next,
   struct mm_walk *walk);
 struct mm_struct *mm;
 struct vm_area_struct *vma;
 void *private;
};

int walk_page_range(unsigned long addr, unsigned long end,
  struct mm_walk *walk);
int walk_page_vma(struct vm_area_struct *vma, 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)) __attribute__((no_instrument_function)) 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 new);
extern void truncate_setsize(struct inode *inode, loff_t newsize);
void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to);
void truncate_pagecache_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);


extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
   unsigned long address, unsigned int flags);
extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
       unsigned long address, unsigned int fault_flags);
# 1137 "include/linux/mm.h"
extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,
  void *buf, int len, int write);

long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
        unsigned long start, unsigned long nr_pages,
        unsigned int foll_flags, struct page **pages,
        struct vm_area_struct **vmas, int *nonblocking);
long get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
      unsigned long start, unsigned long nr_pages,
      int write, int force, struct page **pages,
      struct vm_area_struct **vmas);
long get_user_pages_locked(struct task_struct *tsk, struct mm_struct *mm,
      unsigned long start, unsigned long nr_pages,
      int write, int force, struct page **pages,
      int *locked);
long __get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm,
          unsigned long start, unsigned long nr_pages,
          int write, int force, struct page **pages,
          unsigned int gup_flags);
long get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm,
      unsigned long start, unsigned long nr_pages,
      int write, int force, struct page **pages);
int get_user_pages_fast(unsigned long start, int nr_pages, int write,
   struct page **pages);
struct kvec;
int get_kernel_pages(const struct kvec *iov, int nr_pages, int write,
   struct page **pages);
int get_kernel_page(unsigned long start, 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 int offset,
         unsigned int length);

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);
void account_page_cleaned(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);

int get_cmdline(struct task_struct *task, char *buffer, int buflen);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int vma_growsdown(struct vm_area_struct *vma, unsigned long addr)
{
 return vma && (vma->vm_end == addr) && (vma->vm_flags & 0x00000100);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int stack_guard_page_start(struct vm_area_struct *vma,
          unsigned long addr)
{
 return (vma->vm_flags & 0x00000100) &&
  (vma->vm_start == addr) &&
  !vma_growsdown(vma->vm_prev, addr);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int vma_growsup(struct vm_area_struct *vma, unsigned long addr)
{
 return vma && (vma->vm_start == addr) && (vma->vm_flags & 0x00000000);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int stack_guard_page_end(struct vm_area_struct *vma,
        unsigned long addr)
{
 return (vma->vm_flags & 0x00000000) &&
  (vma->vm_end == addr) &&
  !vma_growsup(vma->vm_next, addr);
}

extern struct task_struct *task_of_stack(struct task_struct *task,
    struct vm_area_struct *vma, bool in_group);

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,
  bool need_rmap_locks);
extern unsigned long change_protection(struct vm_area_struct *vma, unsigned long start,
         unsigned long end, pgprot_t newprot,
         int dirty_accountable, int prot_numa);
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);



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long get_mm_counter(struct mm_struct *mm, int member)
{
 long val = atomic_long_read(&mm->rss_stat.count[member]);






 if (val < 0)
  val = 0;

 return (unsigned long)val;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void add_mm_counter(struct mm_struct *mm, int member, long value)
{
 atomic_long_add(value, &mm->rss_stat.count[member]);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void inc_mm_counter(struct mm_struct *mm, int member)
{
 atomic_long_inc(&mm->rss_stat.count[member]);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void dec_mm_counter(struct mm_struct *mm, int member)
{
 atomic_long_dec(&mm->rss_stat.count[member]);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long get_mm_rss(struct mm_struct *mm)
{
 return get_mm_counter(mm, MM_FILEPAGES) +
  get_mm_counter(mm, MM_ANONPAGES);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long get_mm_hiwater_rss(struct mm_struct *mm)
{
 return ({ typeof(mm->hiwater_rss) _max1 = (mm->hiwater_rss); typeof(get_mm_rss(mm)) _max2 = (get_mm_rss(mm)); (void) (&_max1 == &_max2); _max1 > _max2 ? _max1 : _max2; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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; });
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void update_hiwater_rss(struct mm_struct *mm)
{
 unsigned long _rss = get_mm_rss(mm);

 if ((mm)->hiwater_rss < _rss)
  (mm)->hiwater_rss = _rss;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void update_hiwater_vm(struct mm_struct *mm)
{
 if (mm->hiwater_vm < mm->total_vm)
  mm->hiwater_vm = mm->total_vm;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void reset_mm_hiwater_rss(struct mm_struct *mm)
{
 mm->hiwater_rss = get_mm_rss(mm);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
}


void sync_mm_rss(struct mm_struct *mm);






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)) __attribute__((no_instrument_function)) pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr,
        spinlock_t **ptl)
{
 pte_t *ptep;
 (ptep = __get_locked_pte(mm, addr, ptl));
 return ptep;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __pud_alloc(struct mm_struct *mm, pgd_t *pgd,
      unsigned long address)
{
 return 0;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __pmd_alloc(struct mm_struct *mm, pud_t *pud,
      unsigned long address)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mm_nr_pmds_init(struct mm_struct *mm) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long mm_nr_pmds(struct mm_struct *mm)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mm_inc_nr_pmds(struct mm_struct *mm) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mm_dec_nr_pmds(struct mm_struct *mm) {}
# 1379 "include/linux/mm.h"
int __pte_alloc(struct mm_struct *mm, struct vm_area_struct *vma,
  pmd_t *pmd, unsigned long address);
int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
{
 return (__builtin_expect(!!(pgd_none(*pgd)), 0) && __pud_alloc(mm, pgd, address))?
  ((void *)0): pud_offset(pgd, address);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
{
 return (__builtin_expect(!!((0)), 0) && __pmd_alloc(mm, pud, address))?
  ((void *)0): pmd_offset(pud, address);
}




void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) ptlock_cache_init(void);
extern bool ptlock_alloc(struct page *page);
extern void ptlock_free(struct page *page);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) spinlock_t *ptlock_ptr(struct page *page)
{
 return page->ptl;
}
# 1431 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd)
{
 return ptlock_ptr((mem_map + ((((unsigned long)(((*pmd) & (~0UL)) >> 12))) - (__pv_phys_pfn_offset))));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool ptlock_init(struct page *page)
{
# 1446 "include/linux/mm.h"
 ((void)(sizeof(( long)(*(unsigned long *)&page->ptl))));
 if (!ptlock_alloc(page))
  return false;
 do { spinlock_check(ptlock_ptr(page)); do { static struct lock_class_key __key; __raw_spin_lock_init((&(ptlock_ptr(page))->rlock), "&(ptlock_ptr(page))->rlock", &__key); } while (0); } while (0);
 return true;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pte_lock_deinit(struct page *page)
{
 page->mapping = ((void *)0);
 ptlock_free(page);
}
# 1473 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgtable_init(void)
{
 ptlock_cache_init();
 do { } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool pgtable_page_ctor(struct page *page)
{
 inc_zone_page_state(page, NR_PAGETABLE);
 return ptlock_init(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgtable_page_dtor(struct page *page)
{
 pte_lock_deinit(page);
 dec_zone_page_state(page, NR_PAGETABLE);
}
# 1552 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd)
{
 return &mm->page_table_lock;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool pgtable_pmd_page_ctor(struct page *page) { return true; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pgtable_pmd_page_dtor(struct page *page) {}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) spinlock_t *pmd_lock(struct mm_struct *mm, pmd_t *pmd)
{
 spinlock_t *ptl = pmd_lockptr(mm, pmd);
 spin_lock(ptl);
 return ptl;
}

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);
extern void free_initmem(void);







extern unsigned long free_reserved_area(void *start, void *end,
     int poison, char *s);






extern void free_highmem_page(struct page *page);


extern void adjust_managed_page_count(struct page *page, long count);
extern void mem_init_print_info(const char *str);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __free_reserved_page(struct page *page)
{
 ClearPageReserved(page);
 init_page_count(page);
 __free_pages((page), 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void free_reserved_page(struct page *page)
{
 __free_reserved_page(page);
 adjust_managed_page_count(page, 1);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mark_page_reserved(struct page *page)
{
 SetPageReserved(page);
 adjust_managed_page_count(page, -1);
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long free_initmem_default(int poison)
{
 extern char __init_begin[], __init_end[];

 return free_reserved_area(&__init_begin, &__init_end,
      poison, "unused kernel");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long get_num_physpages(void)
{
 int nid;
 unsigned long phys_pages = 0;

 for ( (nid) = 0; (nid) == 0; (nid) = 1)
  phys_pages += ((&contig_page_data)->node_present_pages);

 return phys_pages;
}
# 1685 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __early_pfn_to_nid(unsigned long pfn)
{
 return 0;
}







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 int __attribute__ ((__section__(".meminit.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) init_per_zone_wmark_min(void);
extern void mem_init(void);
extern void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) mmap_init(void);
extern void show_mem(unsigned int flags);
extern void si_meminfo(struct sysinfo * val);
extern void si_meminfo_node(struct sysinfo *val, int nid);

extern __attribute__((format(printf, 3, 4)))
void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...);

extern void setup_per_cpu_pageset(void);

extern void zone_pcp_update(struct zone *zone);
extern void zone_pcp_reset(struct zone *zone);


extern int min_free_kbytes;


extern atomic_long_t mmap_pages_allocated;
extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t);


void vma_interval_tree_insert(struct vm_area_struct *node,
         struct rb_root *root);
void vma_interval_tree_insert_after(struct vm_area_struct *node,
        struct vm_area_struct *prev,
        struct rb_root *root);
void vma_interval_tree_remove(struct vm_area_struct *node,
         struct rb_root *root);
struct vm_area_struct *vma_interval_tree_iter_first(struct rb_root *root,
    unsigned long start, unsigned long last);
struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node,
    unsigned long start, unsigned long last);





void anon_vma_interval_tree_insert(struct anon_vma_chain *node,
       struct rb_root *root);
void anon_vma_interval_tree_remove(struct anon_vma_chain *node,
       struct rb_root *root);
struct anon_vma_chain *anon_vma_interval_tree_iter_first(
 struct rb_root *root, unsigned long start, unsigned long last);
struct anon_vma_chain *anon_vma_interval_tree_iter_next(
 struct anon_vma_chain *node, unsigned long start, unsigned long last);
# 1756 "include/linux/mm.h"
extern int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin);
extern int 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,
 bool *need_rmap_locks);
extern void exit_mmap(struct mm_struct *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int check_data_rlimit(unsigned long rlim,
        unsigned long new,
        unsigned long start,
        unsigned long end_data,
        unsigned long start_data)
{
 if (rlim < (~0UL)) {
  if (((new - start) + (end_data - start_data)) > rlim)
   return -28;
 }

 return 0;
}

extern int mm_take_all_locks(struct mm_struct *mm);
extern void mm_drop_all_locks(struct mm_struct *mm);

extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
extern struct file *get_mm_exe_file(struct mm_struct *mm);

extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
extern struct vm_area_struct *_install_special_mapping(struct mm_struct *mm,
       unsigned long addr, unsigned long len,
       unsigned long flags,
       const struct vm_special_mapping *spec);

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 mmap_region(struct file *file, unsigned long addr,
 unsigned long len, vm_flags_t vm_flags, unsigned long pgoff);
extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
 unsigned long len, unsigned long prot, unsigned long flags,
 unsigned long pgoff, unsigned long *populate);
extern int do_munmap(struct mm_struct *, unsigned long, size_t);


extern int __mm_populate(unsigned long addr, unsigned long len,
    int ignore_errors);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mm_populate(unsigned long addr, unsigned long len)
{

 (void) __mm_populate(addr, len, 1);
}





extern unsigned long vm_brk(unsigned long, unsigned long);
extern int vm_munmap(unsigned long, size_t);
extern unsigned long vm_mmap(struct file *, unsigned long,
        unsigned long, unsigned long,
        unsigned long, unsigned long);

struct vm_unmapped_area_info {

 unsigned long flags;
 unsigned long length;
 unsigned long low_limit;
 unsigned long high_limit;
 unsigned long align_mask;
 unsigned long align_offset;
};

extern unsigned long unmapped_area(struct vm_unmapped_area_info *info);
extern unsigned long unmapped_area_topdown(struct vm_unmapped_area_info *info);
# 1855 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
vm_unmapped_area(struct vm_unmapped_area_info *info)
{
 if (!(info->flags & 1))
  return unmapped_area(info);
 else
  return unmapped_area_topdown(info);
}


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 void truncate_inode_pages_final(struct address_space *);


extern int filemap_fault(struct vm_area_struct *, struct vm_fault *);
extern void filemap_map_pages(struct vm_area_struct *vma, struct vm_fault *vmf);
extern int filemap_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);


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


extern int expand_stack(struct vm_area_struct *vma, unsigned long address);


extern int expand_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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) unsigned long vma_pages(struct vm_area_struct *vma)
{
 return (vma->vm_end - vma->vm_start) >> 12;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct vm_area_struct *find_exact_vma(struct mm_struct *mm,
    unsigned long vm_start, unsigned long vm_end)
{
 struct vm_area_struct *vma = find_vma(mm, vm_start);

 if (vma && (vma->vm_start != vm_start || vma->vm_end != vm_end))
  vma = ((void *)0);

 return vma;
}


pgprot_t vm_get_page_prot(unsigned long vm_flags);
void vma_set_page_prot(struct vm_area_struct *vma);
# 1965 "include/linux/mm.h"
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);
int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long len);


struct page *follow_page_mask(struct vm_area_struct *vma,
         unsigned long address, unsigned int foll_flags,
         unsigned int *page_mask);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *follow_page(struct vm_area_struct *vma,
  unsigned long address, unsigned int foll_flags)
{
 unsigned int unused_page_mask;
 return follow_page_mask(vma, address, foll_flags, &unused_page_mask);
}
# 2001 "include/linux/mm.h"
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);
# 2037 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
kernel_map_pages(struct page *page, int numpages, int enable) {}






extern struct vm_area_struct *get_gate_vma(struct mm_struct *mm);
extern int in_gate_area_no_mm(unsigned long addr);
extern int in_gate_area(struct mm_struct *mm, unsigned long addr);
# 2061 "include/linux/mm.h"
extern int sysctl_drop_caches;
int drop_caches_sysctl_handler(struct ctl_table *, int,
     void *, size_t *, loff_t *);


void drop_slab(void);
void drop_slab_node(int nid);




extern int randomize_va_space;


const char * arch_vma_name(struct vm_area_struct *vma);
void print_vma_addr(char *prefix, unsigned long rip);

void sparse_mem_maps_populate_node(struct page **map_map,
       unsigned long pnum_begin,
       unsigned long pnum_end,
       unsigned long map_count,
       int nodeid);

struct page *sparse_mem_map_populate(unsigned long pnum, int nid);
pgd_t *vmemmap_pgd_populate(unsigned long addr, int node);
pud_t *vmemmap_pud_populate(pgd_t *pgd, unsigned long addr, int node);
pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node);
pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node);
void *vmemmap_alloc_block(unsigned long size, int node);
void *vmemmap_alloc_block_buf(unsigned long size, int node);
void vmemmap_verify(pte_t *, int, unsigned long, unsigned long);
int vmemmap_populate_basepages(unsigned long start, unsigned long end,
          int node);
int vmemmap_populate(unsigned long start, unsigned long end, int node);
void vmemmap_populate_print_last(void);



void register_page_bootmem_memmap(unsigned long section_nr, struct page *map,
      unsigned long size);

enum mf_flags {
 MF_COUNT_INCREASED = 1 << 0,
 MF_ACTION_REQUIRED = 1 << 1,
 MF_MUST_KILL = 1 << 2,
 MF_SOFT_OFFLINE = 1 << 3,
};
extern int memory_failure(unsigned long pfn, int trapno, int flags);
extern void memory_failure_queue(unsigned long pfn, int trapno, int flags);
extern int unpoison_memory(unsigned long pfn);
extern int sysctl_memory_failure_early_kill;
extern int sysctl_memory_failure_recovery;
extern void shake_page(struct page *p, int access);
extern atomic_long_t num_poisoned_pages;
extern int soft_offline_page(struct page *page, int flags);
# 2126 "include/linux/mm.h"
extern struct page_ext_operations debug_guardpage_ops;
extern struct page_ext_operations page_poisoning_ops;
# 2154 "include/linux/mm.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int debug_guardpage_minorder(void) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool debug_guardpage_enabled(void) { return false; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool page_is_guard(struct page *page) { return false; }





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void setup_nr_node_ids(void) {}
# 5 "include/linux/migrate.h" 2
# 1 "include/linux/mempolicy.h" 1
# 10 "include/linux/mempolicy.h"
# 1 "include/linux/slab.h" 1
# 106 "include/linux/slab.h"
# 1 "include/linux/kmemleak.h" 1
# 24 "include/linux/kmemleak.h"
# 1 "include/linux/slab.h" 1
# 25 "include/linux/kmemleak.h" 2
# 62 "include/linux/kmemleak.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_init(void)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_alloc(const void *ptr, size_t size, int min_count,
      gfp_t gfp)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_alloc_recursive(const void *ptr, size_t size,
         int min_count, unsigned long flags,
         gfp_t gfp)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_alloc_percpu(const void *ptr, size_t size)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_free(const void *ptr)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_free_part(const void *ptr, size_t size)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_free_recursive(const void *ptr, unsigned long flags)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_free_percpu(const void *ptr)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_update_trace(const void *ptr)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_not_leak(const void *ptr)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_ignore(const void *ptr)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_scan_area(const void *ptr, size_t size, gfp_t gfp)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_erase(void **ptr)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmemleak_no_scan(const void *ptr)
{
}
# 107 "include/linux/slab.h" 2
# 1 "include/linux/kasan.h" 1





struct kmem_cache;
struct page;
struct vm_struct;
# 58 "include/linux/kasan.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_unpoison_shadow(const void *address, size_t size) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_enable_current(void) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_disable_current(void) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_alloc_pages(struct page *page, unsigned int order) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_free_pages(struct page *page, unsigned int order) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_poison_slab(struct page *page) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_unpoison_object_data(struct kmem_cache *cache,
     void *object) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_poison_object_data(struct kmem_cache *cache,
     void *object) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_kmalloc_large(void *ptr, size_t size) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_kfree_large(const void *ptr) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_kmalloc(struct kmem_cache *s, const void *object,
    size_t size) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_krealloc(const void *object, size_t new_size) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_slab_alloc(struct kmem_cache *s, void *object) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_slab_free(struct kmem_cache *s, void *object) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kasan_module_alloc(void *addr, size_t size) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kasan_free_shadow(const struct vm_struct *vm) {}
# 108 "include/linux/slab.h" 2

struct mem_cgroup;



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 memcg_create_kmem_cache(struct mem_cgroup *, struct kmem_cache *);
void memcg_deactivate_kmem_caches(struct mem_cgroup *);
void memcg_destroy_kmem_caches(struct mem_cgroup *);
# 141 "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 *);
# 233 "include/linux/slab.h"
extern struct kmem_cache *kmalloc_caches[(12 + 1) + 1];
# 246 "include/linux/slab.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) int kmalloc_index(size_t size)
{
 if (!size)
  return 0;

 if (size <= (1 << 6))
  return ( __builtin_constant_p((1 << 6)) ? ( ((1 << 6)) < 1 ? ____ilog2_NaN() : ((1 << 6)) & (1ULL << 63) ? 63 : ((1 << 6)) & (1ULL << 62) ? 62 : ((1 << 6)) & (1ULL << 61) ? 61 : ((1 << 6)) & (1ULL << 60) ? 60 : ((1 << 6)) & (1ULL << 59) ? 59 : ((1 << 6)) & (1ULL << 58) ? 58 : ((1 << 6)) & (1ULL << 57) ? 57 : ((1 << 6)) & (1ULL << 56) ? 56 : ((1 << 6)) & (1ULL << 55) ? 55 : ((1 << 6)) & (1ULL << 54) ? 54 : ((1 << 6)) & (1ULL << 53) ? 53 : ((1 << 6)) & (1ULL << 52) ? 52 : ((1 << 6)) & (1ULL << 51) ? 51 : ((1 << 6)) & (1ULL << 50) ? 50 : ((1 << 6)) & (1ULL << 49) ? 49 : ((1 << 6)) & (1ULL << 48) ? 48 : ((1 << 6)) & (1ULL << 47) ? 47 : ((1 << 6)) & (1ULL << 46) ? 46 : ((1 << 6)) & (1ULL << 45) ? 45 : ((1 << 6)) & (1ULL << 44) ? 44 : ((1 << 6)) & (1ULL << 43) ? 43 : ((1 << 6)) & (1ULL << 42) ? 42 : ((1 << 6)) & (1ULL << 41) ? 41 : ((1 << 6)) & (1ULL << 40) ? 40 : ((1 << 6)) & (1ULL << 39) ? 39 : ((1 << 6)) & (1ULL << 38) ? 38 : ((1 << 6)) & (1ULL << 37) ? 37 : ((1 << 6)) & (1ULL << 36) ? 36 : ((1 << 6)) & (1ULL << 35) ? 35 : ((1 << 6)) & (1ULL << 34) ? 34 : ((1 << 6)) & (1ULL << 33) ? 33 : ((1 << 6)) & (1ULL << 32) ? 32 : ((1 << 6)) & (1ULL << 31) ? 31 : ((1 << 6)) & (1ULL << 30) ? 30 : ((1 << 6)) & (1ULL << 29) ? 29 : ((1 << 6)) & (1ULL << 28) ? 28 : ((1 << 6)) & (1ULL << 27) ? 27 : ((1 << 6)) & (1ULL << 26) ? 26 : ((1 << 6)) & (1ULL << 25) ? 25 : ((1 << 6)) & (1ULL << 24) ? 24 : ((1 << 6)) & (1ULL << 23) ? 23 : ((1 << 6)) & (1ULL << 22) ? 22 : ((1 << 6)) & (1ULL << 21) ? 21 : ((1 << 6)) & (1ULL << 20) ? 20 : ((1 << 6)) & (1ULL << 19) ? 19 : ((1 << 6)) & (1ULL << 18) ? 18 : ((1 << 6)) & (1ULL << 17) ? 17 : ((1 << 6)) & (1ULL << 16) ? 16 : ((1 << 6)) & (1ULL << 15) ? 15 : ((1 << 6)) & (1ULL << 14) ? 14 : ((1 << 6)) & (1ULL << 13) ? 13 : ((1 << 6)) & (1ULL << 12) ? 12 : ((1 << 6)) & (1ULL << 11) ? 11 : ((1 << 6)) & (1ULL << 10) ? 10 : ((1 << 6)) & (1ULL << 9) ? 9 : ((1 << 6)) & (1ULL << 8) ? 8 : ((1 << 6)) & (1ULL << 7) ? 7 : ((1 << 6)) & (1ULL << 6) ? 6 : ((1 << 6)) & (1ULL << 5) ? 5 : ((1 << 6)) & (1ULL << 4) ? 4 : ((1 << 6)) & (1ULL << 3) ? 3 : ((1 << 6)) & (1ULL << 2) ? 2 : ((1 << 6)) & (1ULL << 1) ? 1 : ((1 << 6)) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof((1 << 6)) <= 4) ? __ilog2_u32((1 << 6)) : __ilog2_u64((1 << 6)) );

 if ((1 << 6) <= 32 && size > 64 && size <= 96)
  return 1;
 if ((1 << 6) <= 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;
 if (size <= 4 * 1024 * 1024) return 22;
 if (size <= 8 * 1024 * 1024) return 23;
 if (size <= 16 * 1024 * 1024) return 24;
 if (size <= 32 * 1024 * 1024) return 25;
 if (size <= 64 * 1024 * 1024) return 26;
 do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/slab.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "282" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);


 return -1;
}


void *__kmalloc(size_t size, gfp_t flags);
void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags);
void kmem_cache_free(struct kmem_cache *, void *);





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *__kmalloc_node(size_t size, gfp_t flags, int node)
{
 return __kmalloc(size, flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t flags, int node)
{
 return kmem_cache_alloc(s, flags);
}
# 326 "include/linux/slab.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *kmem_cache_alloc_trace(struct kmem_cache *s,
  gfp_t flags, size_t size)
{
 void *ret = kmem_cache_alloc(s, flags);

 kasan_kmalloc(s, ret, size);
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *
kmem_cache_alloc_node_trace(struct kmem_cache *s,
         gfp_t gfpflags,
         int node, size_t size)
{
 void *ret = kmem_cache_alloc_node(s, gfpflags, node);

 kasan_kmalloc(s, ret, size);
 return ret;
}


extern void *kmalloc_order(size_t size, gfp_t flags, unsigned int order);




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *
kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order)
{
 return kmalloc_order(size, flags, order);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *kmalloc_large(size_t size, gfp_t flags)
{
 unsigned int order = ( __builtin_constant_p(size) ? ( ((size) == 0UL) ? 32 - 12 : (((size) < (1UL << 12)) ? 0 : ( __builtin_constant_p((size) - 1) ? ( ((size) - 1) < 1 ? ____ilog2_NaN() : ((size) - 1) & (1ULL << 63) ? 63 : ((size) - 1) & (1ULL << 62) ? 62 : ((size) - 1) & (1ULL << 61) ? 61 : ((size) - 1) & (1ULL << 60) ? 60 : ((size) - 1) & (1ULL << 59) ? 59 : ((size) - 1) & (1ULL << 58) ? 58 : ((size) - 1) & (1ULL << 57) ? 57 : ((size) - 1) & (1ULL << 56) ? 56 : ((size) - 1) & (1ULL << 55) ? 55 : ((size) - 1) & (1ULL << 54) ? 54 : ((size) - 1) & (1ULL << 53) ? 53 : ((size) - 1) & (1ULL << 52) ? 52 : ((size) - 1) & (1ULL << 51) ? 51 : ((size) - 1) & (1ULL << 50) ? 50 : ((size) - 1) & (1ULL << 49) ? 49 : ((size) - 1) & (1ULL << 48) ? 48 : ((size) - 1) & (1ULL << 47) ? 47 : ((size) - 1) & (1ULL << 46) ? 46 : ((size) - 1) & (1ULL << 45) ? 45 : ((size) - 1) & (1ULL << 44) ? 44 : ((size) - 1) & (1ULL << 43) ? 43 : ((size) - 1) & (1ULL << 42) ? 42 : ((size) - 1) & (1ULL << 41) ? 41 : ((size) - 1) & (1ULL << 40) ? 40 : ((size) - 1) & (1ULL << 39) ? 39 : ((size) - 1) & (1ULL << 38) ? 38 : ((size) - 1) & (1ULL << 37) ? 37 : ((size) - 1) & (1ULL << 36) ? 36 : ((size) - 1) & (1ULL << 35) ? 35 : ((size) - 1) & (1ULL << 34) ? 34 : ((size) - 1) & (1ULL << 33) ? 33 : ((size) - 1) & (1ULL << 32) ? 32 : ((size) - 1) & (1ULL << 31) ? 31 : ((size) - 1) & (1ULL << 30) ? 30 : ((size) - 1) & (1ULL << 29) ? 29 : ((size) - 1) & (1ULL << 28) ? 28 : ((size) - 1) & (1ULL << 27) ? 27 : ((size) - 1) & (1ULL << 26) ? 26 : ((size) - 1) & (1ULL << 25) ? 25 : ((size) - 1) & (1ULL << 24) ? 24 : ((size) - 1) & (1ULL << 23) ? 23 : ((size) - 1) & (1ULL << 22) ? 22 : ((size) - 1) & (1ULL << 21) ? 21 : ((size) - 1) & (1ULL << 20) ? 20 : ((size) - 1) & (1ULL << 19) ? 19 : ((size) - 1) & (1ULL << 18) ? 18 : ((size) - 1) & (1ULL << 17) ? 17 : ((size) - 1) & (1ULL << 16) ? 16 : ((size) - 1) & (1ULL << 15) ? 15 : ((size) - 1) & (1ULL << 14) ? 14 : ((size) - 1) & (1ULL << 13) ? 13 : ((size) - 1) & (1ULL << 12) ? 12 : ((size) - 1) & (1ULL << 11) ? 11 : ((size) - 1) & (1ULL << 10) ? 10 : ((size) - 1) & (1ULL << 9) ? 9 : ((size) - 1) & (1ULL << 8) ? 8 : ((size) - 1) & (1ULL << 7) ? 7 : ((size) - 1) & (1ULL << 6) ? 6 : ((size) - 1) & (1ULL << 5) ? 5 : ((size) - 1) & (1ULL << 4) ? 4 : ((size) - 1) & (1ULL << 3) ? 3 : ((size) - 1) & (1ULL << 2) ? 2 : ((size) - 1) & (1ULL << 1) ? 1 : ((size) - 1) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof((size) - 1) <= 4) ? __ilog2_u32((size) - 1) : __ilog2_u64((size) - 1) ) - 12 + 1) ) : __get_order(size) );
 return kmalloc_order_trace(size, flags, order);
}
# 418 "include/linux/slab.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *kmalloc(size_t size, gfp_t flags)
{
 if (__builtin_constant_p(size)) {
  if (size > (1UL << (12 + 1)))
   return kmalloc_large(size, flags);

  if (!(flags & (( gfp_t)0x01u))) {
   int index = kmalloc_index(size);

   if (!index)
    return ((void *)16);

   return kmem_cache_alloc_trace(kmalloc_caches[index],
     flags, size);
  }

 }
 return __kmalloc(size, flags);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) int kmalloc_size(int n)
{

 if (n > 2)
  return 1 << n;

 if (n == 1 && (1 << 6) <= 32)
  return 96;

 if (n == 2 && (1 << 6) <= 64)
  return 192;

 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void *kmalloc_node(size_t size, gfp_t flags, int node)
{

 if (__builtin_constant_p(size) &&
  size <= (1UL << (12 + 1)) && !(flags & (( gfp_t)0x01u))) {
  int i = kmalloc_index(size);

  if (!i)
   return ((void *)16);

  return kmem_cache_alloc_node_trace(kmalloc_caches[i],
      flags, node, size);
 }

 return __kmalloc_node(size, flags, node);
}
# 484 "include/linux/slab.h"
struct memcg_cache_array {
 struct callback_head rcu;
 struct kmem_cache *entries[0];
};
# 505 "include/linux/slab.h"
struct memcg_cache_params {
 bool is_root_cache;
 struct list_head list;
 union {
  struct memcg_cache_array *memcg_caches;
  struct {
   struct mem_cgroup *memcg;
   struct kmem_cache *root_cache;
  };
 };
};

int memcg_update_all_caches(int num_memcgs);







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







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *kcalloc(size_t n, size_t size, gfp_t flags)
{
 return kmalloc_array(n, size, flags | (( gfp_t)0x8000u));
}
# 551 "include/linux/slab.h"
extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
# 571 "include/linux/slab.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void *kzalloc(size_t size, gfp_t flags)
{
 return kmalloc(size, flags | (( gfp_t)0x8000u));
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *kzalloc_node(size_t size, gfp_t flags, int node)
{
 return kmalloc_node(size, flags | (( gfp_t)0x8000u), node);
}

unsigned int kmem_cache_size(struct kmem_cache *s);
void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) kmem_cache_init_late(void);
# 11 "include/linux/mempolicy.h" 2



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







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






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



# 1 "include/uapi/linux/kdev_t.h" 1
# 5 "include/linux/kdev_t.h" 2
# 23 "include/linux/kdev_t.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) u16 old_encode_dev(dev_t dev)
{
 return (((unsigned int) ((dev) >> 20)) << 8) | ((unsigned int) ((dev) & ((1U << 20) - 1)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) dev_t old_decode_dev(u16 val)
{
 return ((((val >> 8) & 255) << 20) | (val & 255));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int new_valid_dev(dev_t dev)
{
 return 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) int huge_valid_dev(dev_t dev)
{
 return 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) u64 huge_encode_dev(dev_t dev)
{
 return new_encode_dev(dev);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) dev_t huge_decode_dev(u64 dev)
{
 return new_decode_dev(dev);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) u32 sysv_encode_dev(dev_t dev)
{
 return ((unsigned int) ((dev) & ((1U << 20) - 1))) | (((unsigned int) ((dev) >> 20)) << 18);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned sysv_major(u32 dev)
{
 return (dev >> 18) & 0x3fff;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned sysv_minor(u32 dev)
{
 return dev & 0x3ffff;
}
# 8 "include/linux/fs.h" 2
# 1 "include/linux/dcache.h" 1






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






# 1 "include/linux/list_bl.h" 1
# 33 "include/linux/list_bl.h"
struct hlist_bl_head {
 struct hlist_bl_node *first;
};

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



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void INIT_HLIST_BL_NODE(struct hlist_bl_node *h)
{
 h->next = ((void *)0);
 h->pprev = ((void *)0);
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int hlist_bl_unhashed(const struct hlist_bl_node *h)
{
 return !h->pprev;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct hlist_bl_node *hlist_bl_first(struct hlist_bl_head *h)
{
 return (struct hlist_bl_node *)
  ((unsigned long)h->first & ~1UL);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_set_first(struct hlist_bl_head *h,
     struct hlist_bl_node *n)
{
 ;

                        ;
 h->first = (struct hlist_bl_node *)((unsigned long)n | 1UL);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int hlist_bl_empty(const struct hlist_bl_head *h)
{
 return !((unsigned long)h->first & ~1UL);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_add_head(struct hlist_bl_node *n,
     struct hlist_bl_head *h)
{
 struct hlist_bl_node *first = hlist_bl_first(h);

 n->next = first;
 if (first)
  first->pprev = &n->next;
 n->pprev = &h->first;
 hlist_bl_set_first(h, n);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __hlist_bl_del(struct hlist_bl_node *n)
{
 struct hlist_bl_node *next = n->next;
 struct hlist_bl_node **pprev = n->pprev;

 ;


 *pprev = (struct hlist_bl_node *)
   ((unsigned long)next |
    ((unsigned long)*pprev & 1UL));
 if (next)
  next->pprev = pprev;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_del(struct hlist_bl_node *n)
{
 __hlist_bl_del(n);
 n->next = ((void *) 0x00100100 + 0);
 n->pprev = ((void *) 0x00200200 + 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_del_init(struct hlist_bl_node *n)
{
 if (!hlist_bl_unhashed(n)) {
  __hlist_bl_del(n);
  INIT_HLIST_BL_NODE(n);
 }
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_lock(struct hlist_bl_head *b)
{
 bit_spin_lock(0, (unsigned long *)b);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_unlock(struct hlist_bl_head *b)
{
 __bit_spin_unlock(0, (unsigned long *)b);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool hlist_bl_is_locked(struct hlist_bl_head *b)
{
 return bit_spin_is_locked(0, (unsigned long *)b);
}
# 8 "include/linux/rculist_bl.h" 2


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_set_first_rcu(struct hlist_bl_head *h,
     struct hlist_bl_node *n)
{
 ;

                        ;
 do { do { bool __cond = !((sizeof(*&h->first) == sizeof(char) || sizeof(*&h->first) == sizeof(short) || sizeof(*&h->first) == sizeof(int) || sizeof(*&h->first) == sizeof(long))); extern void
 __compiletime_assert_17
# 16 "include/linux/rculist_bl.h"
 (void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond)
 __compiletime_assert_17
# 16 "include/linux/rculist_bl.h"
 (); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&h->first) __var = ( typeof(*&h->first)) 0; (volatile typeof(*&h->first) *)&(*&h->first); })) = ((typeof(*((struct hlist_bl_node *)((unsigned long)n | 1UL))) *)((struct hlist_bl_node *)((unsigned long)n | 1UL))); } while (0)
                                                                ;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct hlist_bl_node *hlist_bl_first_rcu(struct hlist_bl_head *h)
{
 return (struct hlist_bl_node *)
  ((unsigned long)({ typeof(*(h->first)) *________p1 = (typeof(*(h->first)) *)({ typeof((h->first)) _________p1 = ({ union { typeof((h->first)) __val; char __c[1]; } __u; __read_once_size(&((h->first)), __u.__c, sizeof((h->first))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(h->first)) *)(________p1)); }) & ~1UL);
}
# 46 "include/linux/rculist_bl.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_del_init_rcu(struct hlist_bl_node *n)
{
 if (!hlist_bl_unhashed(n)) {
  __hlist_bl_del(n);
  n->pprev = ((void *)0);
 }
}
# 73 "include/linux/rculist_bl.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_del_rcu(struct hlist_bl_node *n)
{
 __hlist_bl_del(n);
 n->pprev = ((void *) 0x00200200 + 0);
}
# 98 "include/linux/rculist_bl.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void hlist_bl_add_head_rcu(struct hlist_bl_node *n,
     struct hlist_bl_head *h)
{
 struct hlist_bl_node *first;


 first = hlist_bl_first(h);

 n->next = first;
 if (first)
  first->pprev = &n->next;
 n->pprev = &h->first;


 hlist_bl_set_first_rcu(h, n);
}
# 8 "include/linux/dcache.h" 2




# 1 "include/linux/lockref.h" 1
# 24 "include/linux/lockref.h"
struct lockref {
 union {



  struct {
   spinlock_t lock;
   int count;
  };
 };
};

extern void lockref_get(struct lockref *);
extern int lockref_put_return(struct lockref *);
extern int lockref_get_not_zero(struct lockref *);
extern int lockref_get_or_lock(struct lockref *);
extern int lockref_put_or_lock(struct lockref *);

extern void lockref_mark_dead(struct lockref *);
extern int lockref_get_not_dead(struct lockref *);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __lockref_is_dead(const struct lockref *l)
{
 return ((int)l->count < 0);
}
# 13 "include/linux/dcache.h" 2

struct path;
struct vfsmount;
# 44 "include/linux/dcache.h"
struct qstr {
 union {
  struct {
   u32 hash; u32 len;;
  };
  u64 hash_len;
 };
 const unsigned char *name;
};






struct dentry_stat_t {
 long nr_dentry;
 long nr_unused;
 long age_limit;
 long want_pages;
 long dummy[2];
};
extern struct dentry_stat_t dentry_stat;






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
partial_name_hash(unsigned long c, unsigned long prevhash)
{
 return (prevhash + (c << 4) + (c >> 4)) * 11;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long end_name_hash(unsigned long hash)
{
 return (unsigned int) hash;
}


extern unsigned int full_name_hash(const unsigned char *, unsigned int);
# 108 "include/linux/dcache.h"
struct dentry {

 unsigned int d_flags;
 seqcount_t d_seq;
 struct hlist_bl_node d_hash;
 struct dentry *d_parent;
 struct qstr d_name;
 struct inode *d_inode;

 unsigned char d_iname[36];


 struct lockref d_lockref;
 const struct dentry_operations *d_op;
 struct super_block *d_sb;
 unsigned long d_time;
 void *d_fsdata;

 struct list_head d_lru;
 struct list_head d_child;
 struct list_head d_subdirs;



 union {
  struct hlist_node d_alias;
   struct callback_head d_rcu;
 } d_u;
};







enum dentry_d_lock_class
{
 DENTRY_D_LOCK_NORMAL,
 DENTRY_D_LOCK_NESTED
};

struct dentry_operations {
 int (*d_revalidate)(struct dentry *, unsigned int);
 int (*d_weak_revalidate)(struct dentry *, unsigned int);
 int (*d_hash)(const struct dentry *, struct qstr *);
 int (*d_compare)(const struct dentry *, const struct dentry *,
   unsigned int, const char *, const struct qstr *);
 int (*d_delete)(const struct dentry *);
 void (*d_release)(struct dentry *);
 void (*d_prune)(struct dentry *);
 void (*d_iput)(struct dentry *, struct inode *);
 char *(*d_dname)(struct dentry *, char *, int);
 struct vfsmount *(*d_automount)(struct path *);
 int (*d_manage)(struct dentry *, bool);
} __attribute__((__aligned__((1 << 6))));
# 229 "include/linux/dcache.h"
extern seqlock_t rename_lock;




extern void d_instantiate(struct dentry *, struct inode *);
extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
extern int d_instantiate_no_diralias(struct dentry *, struct inode *);
extern void __d_drop(struct dentry *dentry);
extern void d_drop(struct dentry *dentry);
extern void d_delete(struct dentry *);
extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);


extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
extern struct dentry * d_alloc_pseudo(struct super_block *, 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_find_any_alias(struct inode *inode);
extern struct dentry * d_obtain_alias(struct inode *);
extern struct dentry * d_obtain_root(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 void d_invalidate(struct dentry *);


extern struct dentry * d_make_root(struct inode *);


extern void d_genocide(struct dentry *);

extern void d_tmpfile(struct dentry *, struct inode *);

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 *);
# 283 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void d_add(struct dentry *entry, struct inode *inode)
{
 d_instantiate(entry, inode);
 d_rehash(entry);
}
# 297 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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 dentry_update_name_case(struct dentry *, struct qstr *);


extern void d_move(struct dentry *, struct dentry *);
extern void d_exchange(struct dentry *, struct dentry *);
extern struct dentry *d_ancestor(struct dentry *, struct dentry *);


extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
    const struct qstr *name, unsigned *seq);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned d_count(const struct dentry *dentry)
{
 return dentry->d_lockref.count;
}




extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
extern char *simple_dname(struct dentry *, char *, int);

extern char *__d_path(const struct path *, const struct path *, char *, int);
extern char *d_absolute_path(const struct path *, char *, int);
extern char *d_path(const struct path *, char *, int);
extern char *dentry_path_raw(struct dentry *, char *, int);
extern char *dentry_path(struct dentry *, char *, int);
# 347 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct dentry *dget_dlock(struct dentry *dentry)
{
 if (dentry)
  dentry->d_lockref.count++;
 return dentry;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct dentry *dget(struct dentry *dentry)
{
 if (dentry)
  lockref_get(&dentry->d_lockref);
 return dentry;
}

extern struct dentry *dget_parent(struct dentry *dentry);
# 370 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int d_unhashed(const struct dentry *dentry)
{
 return hlist_bl_unhashed(&dentry->d_hash);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int d_unlinked(const struct dentry *dentry)
{
 return d_unhashed(dentry) && !((dentry) == (dentry)->d_parent);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cant_mount(const struct dentry *dentry)
{
 return (dentry->d_flags & 0x00000100);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void dont_mount(struct dentry *dentry)
{
 spin_lock(&dentry->d_lockref.lock);
 dentry->d_flags |= 0x00000100;
 spin_unlock(&dentry->d_lockref.lock);
}

extern void dput(struct dentry *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_managed(const struct dentry *dentry)
{
 return dentry->d_flags & (0x00010000|0x00020000|0x00040000);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_mountpoint(const struct dentry *dentry)
{
 return dentry->d_flags & 0x00010000;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __d_set_type(struct dentry *dentry, unsigned type)
{
 dentry->d_flags = (dentry->d_flags & ~0x00700000) | type;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __d_clear_type(struct dentry *dentry)
{
 __d_set_type(dentry, 0x00000000);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void d_set_type(struct dentry *dentry, unsigned type)
{
 spin_lock(&dentry->d_lockref.lock);
 __d_set_type(dentry, type);
 spin_unlock(&dentry->d_lockref.lock);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned __d_entry_type(const struct dentry *dentry)
{
 return dentry->d_flags & 0x00700000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_miss(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00000000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_whiteout(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00100000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_can_lookup(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00200000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_autodir(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00300000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_dir(const struct dentry *dentry)
{
 return d_can_lookup(dentry) || d_is_autodir(dentry);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_symlink(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00600000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_reg(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00400000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_special(const struct dentry *dentry)
{
 return __d_entry_type(dentry) == 0x00500000;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_file(const struct dentry *dentry)
{
 return d_is_reg(dentry) || d_is_special(dentry);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_negative(const struct dentry *dentry)
{

 return d_is_miss(dentry);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_positive(const struct dentry *dentry)
{
 return !d_is_negative(dentry);
}

extern void d_set_fallthru(struct dentry *dentry);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool d_is_fallthru(const struct dentry *dentry)
{
 return dentry->d_flags & 0x01000000;
}


extern int sysctl_vfs_cache_pressure;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long vfs_pressure_ratio(unsigned long val)
{
 return ( { typeof(val) quot = (val) / (100); typeof(val) rem = (val) % (100); (quot * (sysctl_vfs_cache_pressure)) + ((rem * (sysctl_vfs_cache_pressure)) / (100)); } );
}
# 507 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct inode *d_inode(const struct dentry *dentry)
{
 return dentry->d_inode;
}
# 519 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct inode *d_inode_rcu(const struct dentry *dentry)
{
 return (*({ __attribute__((unused)) typeof(dentry->d_inode) __var = ( typeof(dentry->d_inode)) 0; (volatile typeof(dentry->d_inode) *)&(dentry->d_inode); }));
}
# 534 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct inode *d_backing_inode(const struct dentry *upper)
{
 struct inode *inode = upper->d_inode;

 return inode;
}
# 551 "include/linux/dcache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct dentry *d_backing_dentry(struct dentry *upper)
{
 return upper;
}
# 9 "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(const struct path *);
extern void path_put(const struct path *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int path_equal(const struct path *path1, const struct path *path2)
{
 return path1->mnt == path2->mnt && path1->dentry == path2->dentry;
}
# 10 "include/linux/fs.h" 2
# 1 "include/linux/stat.h" 1




# 1 "./arch/arm/include/uapi/asm/stat.h" 1



struct __old_kernel_stat {
 unsigned short st_dev;
 unsigned short st_ino;
 unsigned short st_mode;
 unsigned short st_nlink;
 unsigned short st_uid;
 unsigned short st_gid;
 unsigned short st_rdev;
 unsigned long st_size;
 unsigned long st_atime;
 unsigned long st_mtime;
 unsigned long st_ctime;
};



struct stat {




 unsigned long st_dev;

 unsigned long st_ino;
 unsigned short st_mode;
 unsigned short st_nlink;
 unsigned short st_uid;
 unsigned short st_gid;




 unsigned long st_rdev;

 unsigned long st_size;
 unsigned long st_blksize;
 unsigned long st_blocks;
 unsigned long st_atime;
 unsigned long st_atime_nsec;
 unsigned long st_mtime;
 unsigned long st_mtime_nsec;
 unsigned long st_ctime;
 unsigned long st_ctime_nsec;
 unsigned long __unused4;
 unsigned long __unused5;
};






struct stat64 {
 unsigned long long st_dev;
 unsigned char __pad0[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 __pad3[4];

 long long st_size;
 unsigned long st_blksize;
 unsigned 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;
};
# 6 "include/linux/stat.h" 2
# 1 "include/uapi/linux/stat.h" 1
# 7 "include/linux/stat.h" 2
# 21 "include/linux/stat.h"
struct kstat {
 u64 ino;
 dev_t dev;
 umode_t mode;
 unsigned int nlink;
 kuid_t uid;
 kgid_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/fs.h" 2


# 1 "include/linux/list_lru.h" 1
# 14 "include/linux/list_lru.h"
struct mem_cgroup;


enum lru_status {
 LRU_REMOVED,
 LRU_REMOVED_RETRY,

 LRU_ROTATE,
 LRU_SKIP,
 LRU_RETRY,

};

struct list_lru_one {
 struct list_head list;

 long nr_items;
};

struct list_lru_memcg {

 struct list_lru_one *lru[0];
};

struct list_lru_node {

 spinlock_t lock;

 struct list_lru_one lru;




} __attribute__((__aligned__((1 << 6))));

struct list_lru {
 struct list_lru_node *node;



};

void list_lru_destroy(struct list_lru *lru);
int __list_lru_init(struct list_lru *lru, bool memcg_aware,
      struct lock_class_key *key);





int memcg_update_all_list_lrus(int num_memcgs);
void memcg_drain_all_list_lrus(int src_idx, int dst_idx);
# 83 "include/linux/list_lru.h"
bool list_lru_add(struct list_lru *lru, struct list_head *item);
# 96 "include/linux/list_lru.h"
bool list_lru_del(struct list_lru *lru, struct list_head *item);
# 108 "include/linux/list_lru.h"
unsigned long list_lru_count_one(struct list_lru *lru,
     int nid, struct mem_cgroup *memcg);
unsigned long list_lru_count_node(struct list_lru *lru, int nid);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long list_lru_shrink_count(struct list_lru *lru,
        struct shrink_control *sc)
{
 return list_lru_count_one(lru, sc->nid, sc->memcg);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long list_lru_count(struct list_lru *lru)
{
 long count = 0;
 int nid;

 for ( (nid) = 0; (nid) == 0; (nid) = 1)
  count += list_lru_count_node(lru, nid);

 return count;
}

void list_lru_isolate(struct list_lru_one *list, struct list_head *item);
void list_lru_isolate_move(struct list_lru_one *list, struct list_head *item,
      struct list_head *head);

typedef enum lru_status (*list_lru_walk_cb)(struct list_head *item,
  struct list_lru_one *list, spinlock_t *lock, void *cb_arg);
# 158 "include/linux/list_lru.h"
unsigned long list_lru_walk_one(struct list_lru *lru,
    int nid, struct mem_cgroup *memcg,
    list_lru_walk_cb isolate, void *cb_arg,
    unsigned long *nr_to_walk);
unsigned long list_lru_walk_node(struct list_lru *lru, int nid,
     list_lru_walk_cb isolate, void *cb_arg,
     unsigned long *nr_to_walk);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
list_lru_shrink_walk(struct list_lru *lru, struct shrink_control *sc,
       list_lru_walk_cb isolate, void *cb_arg)
{
 return list_lru_walk_one(lru, sc->nid, sc->memcg, isolate, cb_arg,
     &sc->nr_to_scan);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
list_lru_walk(struct list_lru *lru, list_lru_walk_cb isolate,
       void *cb_arg, unsigned long nr_to_walk)
{
 long isolated = 0;
 int nid;

 for ( (nid) = 0; (nid) == 0; (nid) = 1) {
  isolated += list_lru_walk_node(lru, nid, isolate,
            cb_arg, &nr_to_walk);
  if (nr_to_walk <= 0)
   break;
 }
 return isolated;
}
# 14 "include/linux/fs.h" 2

# 1 "include/linux/radix-tree.h" 1
# 54 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int radix_tree_is_indirect_ptr(void *ptr)
{
 return (int)((unsigned long)ptr & 1);
}
# 87 "include/linux/radix-tree.h"
struct radix_tree_node {
 unsigned int path;
 unsigned int count;
 union {
  struct {

   struct radix_tree_node *parent;

   void *private_data;
  };

  struct callback_head callback_head;
 };

 struct list_head private_list;
 void *slots[(1UL << (0 ? 4 : 6))];
 unsigned long tags[3][(((1UL << (0 ? 4 : 6)) + 32 - 1) / 32)];
};


struct radix_tree_root {
 unsigned int height;
 gfp_t gfp_mask;
 struct radix_tree_node *rnode;
};
# 194 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *radix_tree_deref_slot(void **pslot)
{
 return ({ typeof(*(*pslot)) *________p1 = (typeof(*(*pslot)) *)({ typeof((*pslot)) _________p1 = ({ union { typeof((*pslot)) __val; char __c[1]; } __u; __read_once_size(&((*pslot)), __u.__c, sizeof((*pslot))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(*pslot)) *)(________p1)); });
}
# 209 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *radix_tree_deref_slot_protected(void **pslot,
       spinlock_t *treelock)
{
 return ({ do { } while (0); ; ((typeof(*(*pslot)) *)((*pslot))); });
}
# 222 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int radix_tree_deref_retry(void *arg)
{
 return __builtin_expect(!!((unsigned long)arg & 1), 0);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int radix_tree_exceptional_entry(void *arg)
{

 return (unsigned long)arg & 2;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int radix_tree_exception(void *arg)
{
 return __builtin_expect(!!((unsigned long)arg & (1 | 2)), 0)
                                                           ;
}
# 257 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void radix_tree_replace_slot(void **pslot, void *item)
{
 do { if (__builtin_expect(!!(radix_tree_is_indirect_ptr(item)), 0)) do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/radix-tree.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "259" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0); } while (0);
 do { do { bool __cond = !((sizeof(*&*pslot) == sizeof(char) || sizeof(*&*pslot) == sizeof(short) || sizeof(*&*pslot) == sizeof(int) || sizeof(*&*pslot) == sizeof(long))); extern void __compiletime_assert_260(void) __attribute__((error("Need native word sized stores/loads for atomicity."))); if (__cond) __compiletime_assert_260(); do { } while (0); } while (0); __asm__ __volatile__ ("dmb " "ish" : : : "memory"); (*({ __attribute__((unused)) typeof(*&*pslot) __var = ( typeof(*&*pslot)) 0; (volatile typeof(*&*pslot) *)&(*&*pslot); })) = ((typeof(*(item)) *)(item)); } while (0);
}

int __radix_tree_create(struct radix_tree_root *root, unsigned long index,
   struct radix_tree_node **nodep, void ***slotp);
int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
void *__radix_tree_lookup(struct radix_tree_root *root, unsigned long index,
     struct radix_tree_node **nodep, void ***slotp);
void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
void **radix_tree_lookup_slot(struct radix_tree_root *, unsigned long);
bool __radix_tree_delete_node(struct radix_tree_root *root,
         struct radix_tree_node *node);
void *radix_tree_delete_item(struct radix_tree_root *, unsigned long, void *);
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 *indices,
   unsigned long first_index, unsigned int max_items);
int radix_tree_preload(gfp_t gfp_mask);
int radix_tree_maybe_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);
unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
  unsigned long *first_indexp, unsigned long last_index,
  unsigned long nr_to_tag,
  unsigned int fromtag, unsigned int totag);
int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
unsigned long radix_tree_locate_item(struct radix_tree_root *root, void *item);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void radix_tree_preload_end(void)
{
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}
# 323 "include/linux/radix-tree.h"
struct radix_tree_iter {
 unsigned long index;
 unsigned long next_index;
 unsigned long tags;
};
# 340 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void **
radix_tree_iter_init(struct radix_tree_iter *iter, unsigned long start)
{
# 351 "include/linux/radix-tree.h"
 iter->index = 0;
 iter->next_index = start;
 return ((void *)0);
}
# 369 "include/linux/radix-tree.h"
void **radix_tree_next_chunk(struct radix_tree_root *root,
        struct radix_tree_iter *iter, unsigned flags);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) unsigned
radix_tree_chunk_size(struct radix_tree_iter *iter)
{
 return iter->next_index - iter->index;
}
# 395 "include/linux/radix-tree.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void **
radix_tree_next_slot(void **slot, struct radix_tree_iter *iter, unsigned flags)
{
 if (flags & 0x0100) {
  iter->tags >>= 1;
  if (__builtin_expect(!!(iter->tags & 1ul), 1)) {
   iter->index++;
   return slot + 1;
  }
  if (!(flags & 0x0200) && __builtin_expect(!!(iter->tags), 1)) {
   unsigned offset = __ffs(iter->tags);

   iter->tags >>= offset;
   iter->index += offset + 1;
   return slot + offset + 1;
  }
 } else {
  unsigned size = radix_tree_chunk_size(iter) - 1;

  while (size--) {
   slot++;
   iter->index++;
   if (__builtin_expect(!!(*slot), 1))
    return slot;
   if (flags & 0x0200) {

    iter->next_index = 0;
    break;
   }
  }
 }
 return ((void *)0);
}
# 16 "include/linux/fs.h" 2







# 1 "include/linux/semaphore.h" 1
# 16 "include/linux/semaphore.h"
struct semaphore {
 raw_spinlock_t lock;
 unsigned int count;
 struct list_head wait_list;
};
# 32 "include/linux/semaphore.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sema_init(struct semaphore *sem, int val)
{
 static struct lock_class_key __key;
 *sem = (struct semaphore) { .lock = (raw_spinlock_t) { .raw_lock = { { 0 } }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), }, .count = val, .wait_list = { &((*sem).wait_list), &((*sem).wait_list) }, };
 do { (void)("semaphore->lock"); (void)(&__key); } while (0);
}

extern void down(struct semaphore *sem);
extern int __attribute__((warn_unused_result)) down_interruptible(struct semaphore *sem);
extern int __attribute__((warn_unused_result)) down_killable(struct semaphore *sem);
extern int __attribute__((warn_unused_result)) down_trylock(struct semaphore *sem);
extern int __attribute__((warn_unused_result)) down_timeout(struct semaphore *sem, long jiffies);
extern void up(struct semaphore *sem);
# 24 "include/linux/fs.h" 2
# 1 "./include/uapi/linux/fiemap.h" 1
# 16 "./include/uapi/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];
};
# 25 "include/linux/fs.h" 2



# 1 "include/linux/migrate_mode.h" 1
# 10 "include/linux/migrate_mode.h"
enum migrate_mode {
 MIGRATE_ASYNC,
 MIGRATE_SYNC_LIGHT,
 MIGRATE_SYNC,
};
# 29 "include/linux/fs.h" 2


# 1 "include/linux/percpu-rwsem.h" 1
# 10 "include/linux/percpu-rwsem.h"
struct percpu_rw_semaphore {
 unsigned int *fast_read_ctr;
 atomic_t write_ctr;
 struct rw_semaphore rw_sem;
 atomic_t slow_read_ctr;
 wait_queue_head_t write_waitq;
};

extern void percpu_down_read(struct percpu_rw_semaphore *);
extern void percpu_up_read(struct percpu_rw_semaphore *);

extern void percpu_down_write(struct percpu_rw_semaphore *);
extern void percpu_up_write(struct percpu_rw_semaphore *);

extern int __percpu_init_rwsem(struct percpu_rw_semaphore *,
    const char *, struct lock_class_key *);
extern void percpu_free_rwsem(struct percpu_rw_semaphore *);
# 32 "include/linux/fs.h" 2
# 1 "include/linux/blk_types.h" 1
# 10 "include/linux/blk_types.h"
struct bio_set;
struct bio;
struct bio_integrity_payload;
struct page;
struct block_device;
struct io_context;
struct cgroup_subsys_state;
typedef void (bio_end_io_t) (struct bio *, int);
typedef void (bio_destructor_t) (struct bio *);




struct bio_vec {
 struct page *bv_page;
 unsigned int bv_len;
 unsigned int bv_offset;
};



struct bvec_iter {
 sector_t bi_sector;

 unsigned int bi_size;

 unsigned int bi_idx;

 unsigned int bi_bvec_done;

};





struct bio {
 struct bio *bi_next;
 struct block_device *bi_bdev;
 unsigned long bi_flags;
 unsigned long bi_rw;



 struct bvec_iter bi_iter;




 unsigned int bi_phys_segments;





 unsigned int bi_seg_front_size;
 unsigned int bi_seg_back_size;

 atomic_t bi_remaining;

 bio_end_io_t *bi_end_io;

 void *bi_private;
# 81 "include/linux/blk_types.h"
 union {



 };

 unsigned short bi_vcnt;





 unsigned short bi_max_vecs;

 atomic_t bi_cnt;

 struct bio_vec *bi_io_vec;

 struct bio_set *bi_pool;






 struct bio_vec bi_inline_vecs[0];
};
# 150 "include/linux/blk_types.h"
enum rq_flag_bits {

 __REQ_WRITE,
 __REQ_FAILFAST_DEV,
 __REQ_FAILFAST_TRANSPORT,
 __REQ_FAILFAST_DRIVER,

 __REQ_SYNC,
 __REQ_META,
 __REQ_PRIO,
 __REQ_DISCARD,
 __REQ_SECURE,
 __REQ_WRITE_SAME,

 __REQ_NOIDLE,
 __REQ_INTEGRITY,
 __REQ_FUA,
 __REQ_FLUSH,


 __REQ_RAHEAD,
 __REQ_THROTTLED,



 __REQ_SORTED,
 __REQ_SOFTBARRIER,
 __REQ_NOMERGE,
 __REQ_STARTED,
 __REQ_DONTPREP,
 __REQ_QUEUED,
 __REQ_ELVPRIV,
 __REQ_FAILED,
 __REQ_QUIET,
 __REQ_PREEMPT,
 __REQ_ALLOCED,
 __REQ_COPY_USER,
 __REQ_FLUSH_SEQ,
 __REQ_IO_STAT,
 __REQ_MIXED_MERGE,
 __REQ_PM,
 __REQ_HASHED,
 __REQ_MQ_INFLIGHT,
 __REQ_NO_TIMEOUT,
 __REQ_NR_BITS,
};
# 33 "include/linux/fs.h" 2


# 1 "include/uapi/linux/fs.h" 1
# 9 "include/uapi/linux/fs.h"
# 1 "./include/uapi/linux/limits.h" 1
# 10 "include/uapi/linux/fs.h" 2
# 1 "./include/uapi/linux/ioctl.h" 1



# 1 "arch/arm/include/generated/asm/ioctl.h" 1
# 1 "include/asm-generic/ioctl.h" 1



# 1 "include/uapi/asm-generic/ioctl.h" 1
# 5 "include/asm-generic/ioctl.h" 2





extern unsigned int __invalid_size_argument_for_IOC;
# 1 "arch/arm/include/generated/asm/ioctl.h" 2
# 5 "./include/uapi/linux/ioctl.h" 2
# 11 "include/uapi/linux/fs.h" 2
# 42 "include/uapi/linux/fs.h"
struct fstrim_range {
 __u64 start;
 __u64 len;
 __u64 minlen;
};


struct files_stat_struct {
 unsigned long nr_files;
 unsigned long nr_free_files;
 unsigned long max_files;
};

struct inodes_stat_t {
 long nr_inodes;
 long nr_unused;
 long dummy[5];
};
# 36 "include/linux/fs.h" 2

struct backing_dev_info;
struct export_operations;
struct hd_geometry;
struct iovec;
struct nameidata;
struct kiocb;
struct kobject;
struct pipe_inode_info;
struct poll_table_struct;
struct kstatfs;
struct vm_area_struct;
struct vfsmount;
struct cred;
struct swap_info_struct;
struct seq_file;
struct workqueue_struct;
struct iov_iter;
struct vm_fault;

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 unsigned long 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 sysctl_protected_symlinks;
extern int sysctl_protected_hardlinks;

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);
# 244 "include/linux/fs.h"
struct iattr {
 unsigned int ia_valid;
 umode_t ia_mode;
 kuid_t ia_uid;
 kgid_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
# 42 "include/linux/quota.h"
# 1 "./include/uapi/linux/dqblk_xfs.h" 1
# 51 "./include/uapi/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;
# 147 "./include/uapi/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;
# 190 "./include/uapi/linux/dqblk_xfs.h"
struct fs_qfilestatv {
 __u64 qfs_ino;
 __u64 qfs_nblks;
 __u32 qfs_nextents;
 __u32 qfs_pad;
};

struct fs_quota_statv {
 __s8 qs_version;
 __u8 qs_pad1;
 __u16 qs_flags;
 __u32 qs_incoredqs;
 struct fs_qfilestatv qs_uquota;
 struct fs_qfilestatv qs_gquota;
 struct fs_qfilestatv qs_pquota;
 __s32 qs_btimelimit;
 __s32 qs_itimelimit;
 __s32 qs_rtbtimelimit;
 __u16 qs_bwarnlimit;
 __u16 qs_iwarnlimit;
 __u64 qs_pad2[8];
};
# 43 "include/linux/quota.h" 2
# 1 "include/linux/dqblk_v1.h" 1
# 44 "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)) __attribute__((no_instrument_function)) 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
# 45 "include/linux/quota.h" 2



# 1 "include/linux/projid.h" 1
# 16 "include/linux/projid.h"
struct user_namespace;
extern struct user_namespace init_user_ns;

typedef __kernel_uid32_t projid_t;

typedef struct {
 projid_t val;
} kprojid_t;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) projid_t __kprojid_val(kprojid_t projid)
{
 return projid.val;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool projid_eq(kprojid_t left, kprojid_t right)
{
 return __kprojid_val(left) == __kprojid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool projid_lt(kprojid_t left, kprojid_t right)
{
 return __kprojid_val(left) < __kprojid_val(right);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool projid_valid(kprojid_t projid)
{
 return !projid_eq(projid, (kprojid_t){ -1 });
}
# 64 "include/linux/projid.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) kprojid_t make_kprojid(struct user_namespace *from, projid_t projid)
{
 return (kprojid_t){ projid };
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) projid_t from_kprojid(struct user_namespace *to, kprojid_t kprojid)
{
 return __kprojid_val(kprojid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) projid_t from_kprojid_munged(struct user_namespace *to, kprojid_t kprojid)
{
 projid_t projid = from_kprojid(to, kprojid);
 if (projid == (projid_t)-1)
  projid = 65534;
 return projid;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool kprojid_has_mapping(struct user_namespace *ns, kprojid_t projid)
{
 return true;
}
# 49 "include/linux/quota.h" 2
# 1 "include/uapi/linux/quota.h" 1
# 88 "include/uapi/linux/quota.h"
enum {
 QIF_BLIMITS_B = 0,
 QIF_SPACE_B,
 QIF_ILIMITS_B,
 QIF_INODES_B,
 QIF_BTIME_B,
 QIF_ITIME_B,
};
# 108 "include/uapi/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;
};
# 129 "include/uapi/linux/quota.h"
enum {
 DQF_ROOT_SQUASH_B = 0,
 DQF_SYS_FILE_B = 16,

 DQF_PRIVATE
};






struct if_dqinfo {
 __u64 dqi_bgrace;
 __u64 dqi_igrace;
 __u32 dqi_flags;
 __u32 dqi_valid;
};
# 163 "include/uapi/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,
};
# 50 "include/linux/quota.h" 2



enum quota_type {
 USRQUOTA = 0,
 GRPQUOTA = 1,
 PRJQUOTA = 2,
};






typedef __kernel_uid32_t qid_t;
typedef long long qsize_t;

struct kqid {
 union {
  kuid_t uid;
  kgid_t gid;
  kprojid_t projid;
 };
 enum quota_type type;
};

extern bool qid_eq(struct kqid left, struct kqid right);
extern bool qid_lt(struct kqid left, struct kqid right);
extern qid_t from_kqid(struct user_namespace *to, struct kqid qid);
extern qid_t from_kqid_munged(struct user_namespace *to, struct kqid qid);
extern bool qid_valid(struct kqid qid);
# 96 "include/linux/quota.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kqid make_kqid(struct user_namespace *from,
        enum quota_type type, qid_t qid)
{
 struct kqid kqid;

 kqid.type = type;
 switch (type) {
 case USRQUOTA:
  kqid.uid = make_kuid(from, qid);
  break;
 case GRPQUOTA:
  kqid.gid = make_kgid(from, qid);
  break;
 case PRJQUOTA:
  kqid.projid = make_kprojid(from, qid);
  break;
 default:
  do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/quota.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "113" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
 }
 return kqid;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kqid make_kqid_invalid(enum quota_type type)
{
 struct kqid kqid;

 kqid.type = type;
 switch (type) {
 case USRQUOTA:
  kqid.uid = (kuid_t){ -1 };
  break;
 case GRPQUOTA:
  kqid.gid = (kgid_t){ -1 };
  break;
 case PRJQUOTA:
  kqid.projid = (kprojid_t){ -1 };
  break;
 default:
  do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/quota.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "140" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0);
 }
 return kqid;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kqid make_kqid_uid(kuid_t uid)
{
 struct kqid kqid;
 kqid.type = USRQUOTA;
 kqid.uid = uid;
 return kqid;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kqid make_kqid_gid(kgid_t gid)
{
 struct kqid kqid;
 kqid.type = GRPQUOTA;
 kqid.gid = gid;
 return kqid;
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kqid make_kqid_projid(kprojid_t projid)
{
 struct kqid kqid;
 kqid.type = PRJQUOTA;
 kqid.projid = projid;
 return kqid;
}


extern spinlock_t dq_data_lock;
# 194 "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_max_spc_limit;
 qsize_t dqi_max_ino_limit;
 void *dqi_priv;
};

struct super_block;






enum {
 DQF_INFO_DIRTY_B = DQF_PRIVATE,
};


extern void mark_info_dirty(struct super_block *sb, int type);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int info_dirty(struct mem_dqinfo *info)
{
 return test_bit(DQF_INFO_DIRTY_B, &info->dqi_flags);
}

enum {
 DQST_LOOKUPS,
 DQST_DROPS,
 DQST_READS,
 DQST_WRITES,
 DQST_CACHE_HITS,
 DQST_ALLOC_DQUOTS,
 DQST_FREE_DQUOTS,
 DQST_SYNCS,
 _DQST_DQSTAT_LAST
};

struct dqstats {
 int stat[_DQST_DQSTAT_LAST];
 struct percpu_counter counter[_DQST_DQSTAT_LAST];
};

extern struct dqstats *dqstats_pcpu;
extern struct dqstats dqstats;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void dqstats_inc(unsigned int type)
{
 percpu_counter_inc(&dqstats.counter[type]);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void dqstats_dec(unsigned int type)
{
 percpu_counter_dec(&dqstats.counter[type]);
}
# 284 "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;
 struct kqid dq_id;
 loff_t dq_off;
 unsigned long dq_flags;
 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 (*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);


 qsize_t *(*get_reserved_space) (struct inode *);
};

struct path;


struct qc_dqblk {
 int d_fieldmask;
 u64 d_spc_hardlimit;
 u64 d_spc_softlimit;
 u64 d_ino_hardlimit;
 u64 d_ino_softlimit;
 u64 d_space;
 u64 d_ino_count;
 s64 d_ino_timer;

 s64 d_spc_timer;
 int d_ino_warns;
 int d_spc_warns;
 u64 d_rt_spc_hardlimit;
 u64 d_rt_spc_softlimit;
 u64 d_rt_space;
 s64 d_rt_spc_timer;
 int d_rt_spc_warns;
};
# 379 "include/linux/quota.h"
struct qc_type_state {
 unsigned int flags;
 unsigned int spc_timelimit;

 unsigned int ino_timelimit;
 unsigned int rt_spc_timelimit;
 unsigned int spc_warnlimit;
 unsigned int ino_warnlimit;
 unsigned int rt_spc_warnlimit;
 unsigned long long ino;
 blkcnt_t blocks;
 blkcnt_t nextents;
};

struct qc_state {
 unsigned int s_incoredqs;






 struct qc_type_state s_state[3];
};


struct qc_info {
 int i_fieldmask;
 unsigned int i_flags;
 unsigned int i_spc_timelimit;

 unsigned int i_ino_timelimit;
 unsigned int i_rt_spc_timelimit;
 unsigned int i_spc_warnlimit;
 unsigned int i_ino_warnlimit;
 unsigned int i_rt_spc_warnlimit;
};


struct quotactl_ops {
 int (*quota_on)(struct super_block *, int, int, struct path *);
 int (*quota_off)(struct super_block *, int);
 int (*quota_enable)(struct super_block *, unsigned int);
 int (*quota_disable)(struct super_block *, unsigned int);
 int (*quota_sync)(struct super_block *, int);
 int (*set_info)(struct super_block *, int, struct qc_info *);
 int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
 int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
 int (*get_state)(struct super_block *, struct qc_state *);
 int (*rm_xquota)(struct super_block *, unsigned int);
};

struct quota_format_type {
 int qf_fmt_id;
 const struct quota_format_ops *qf_ops;
 struct module *qf_owner;
 struct quota_format_type *qf_next;
};
# 451 "include/linux/quota.h"
enum {
 _DQUOT_USAGE_ENABLED = 0,
 _DQUOT_LIMITS_ENABLED,
 _DQUOT_SUSPENDED,


 _DQUOT_STATE_FLAGS
};
# 475 "include/linux/quota.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int dquot_state_flag(unsigned int flags, int type)
{
 return flags << type;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int dquot_generic_flag(unsigned int flags, int type)
{
 return (flags >> type) & ((1 << _DQUOT_USAGE_ENABLED * 2) | (1 << _DQUOT_LIMITS_ENABLED * 2) | (1 << _DQUOT_SUSPENDED * 2));
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) unsigned dquot_state_types(unsigned flags, unsigned flag)
{
 do { bool __cond = !(!((flag) == 0 || (((flag) & ((flag) - 1)) != 0))); extern void __compiletime_assert_488(void) __attribute__((error("BUILD_BUG_ON failed: " "(flag) == 0 || (((flag) & ((flag) - 1)) != 0)"))); if (__cond) __compiletime_assert_488(); do { } while (0); } while (0);
 return (flags / flag) & ((1 << 2) - 1);
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void quota_send_warning(struct kqid qid, dev_t dev,
          const char warntype)
{
 return;
}


struct quota_info {
 unsigned int flags;
 struct mutex dqio_mutex;
 struct mutex dqonoff_mutex;
 struct inode *files[2];
 struct mem_dqinfo info[2];
 const 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;
};
# 266 "include/linux/fs.h" 2
# 299 "include/linux/fs.h"
enum positive_aop_returns {
 AOP_WRITEPAGE_ACTIVATE = 0x80000,
 AOP_TRUNCATED_PAGE = 0x80001,
};
# 313 "include/linux/fs.h"
struct page;
struct address_space;
struct writeback_control;



struct kiocb {
 struct file *ki_filp;
 loff_t ki_pos;
 void (*ki_complete)(struct kiocb *iocb, long ret, long ret2);
 void *private;
 int ki_flags;
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool is_sync_kiocb(struct kiocb *kiocb)
{
 return kiocb->ki_complete == ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
{
 *kiocb = (struct kiocb) {
  .ki_filp = filp,
 };
}
# 348 "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 *);


 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 int, unsigned int);
 int (*releasepage) (struct page *, gfp_t);
 void (*freepage)(struct page *);
 ssize_t (*direct_IO)(int, struct kiocb *, struct iov_iter *iter, loff_t offset);




 int (*migratepage) (struct address_space *,
   struct page *, struct page *, enum migrate_mode);
 int (*launder_page) (struct page *);
 int (*is_partially_uptodate) (struct page *, unsigned long,
     unsigned long);
 void (*is_dirty_writeback) (struct page *, bool *, bool *);
 int (*error_remove_page)(struct address_space *, struct page *);


 int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
    sector_t *span);
 void (*swap_deactivate)(struct file *file);
};

extern const struct address_space_operations empty_aops;





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 address_space {
 struct inode *host;
 struct radix_tree_root page_tree;
 spinlock_t tree_lock;
 atomic_t i_mmap_writable;
 struct rb_root i_mmap;
 struct rw_semaphore i_mmap_rwsem;

 unsigned long nrpages;
 unsigned long nrshadows;
 unsigned long writeback_index;
 const struct address_space_operations *a_ops;
 unsigned long flags;
 spinlock_t private_lock;
 struct list_head private_list;
 void *private_data;
} __attribute__((aligned(sizeof(long))));





struct request_queue;

struct block_device {
 dev_t bd_dev;
 int bd_openers;
 struct inode * bd_inode;
 struct super_block * bd_super;
 struct mutex bd_mutex;
 struct list_head bd_inodes;
 void * bd_claiming;
 void * bd_holder;
 int bd_holders;
 bool bd_write_holder;

 struct list_head bd_holder_disks;

 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 request_queue * bd_queue;
 struct list_head bd_list;






 unsigned long bd_private;


 int bd_fsfreeze_count;

 struct mutex bd_fsfreeze_mutex;
};
# 488 "include/linux/fs.h"
int mapping_tagged(struct address_space *mapping, int tag);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_mmap_lock_write(struct address_space *mapping)
{
 down_write(&mapping->i_mmap_rwsem);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_mmap_unlock_write(struct address_space *mapping)
{
 up_write(&mapping->i_mmap_rwsem);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_mmap_lock_read(struct address_space *mapping)
{
 down_read(&mapping->i_mmap_rwsem);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_mmap_unlock_read(struct address_space *mapping)
{
 up_read(&mapping->i_mmap_rwsem);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mapping_mapped(struct address_space *mapping)
{
 return !((&mapping->i_mmap)->rb_node == ((void *)0));
}
# 527 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mapping_writably_mapped(struct address_space *mapping)
{
 return (*({ __attribute__((unused)) typeof((&mapping->i_mmap_writable)->counter) __var = ( typeof((&mapping->i_mmap_writable)->counter)) 0; (volatile typeof((&mapping->i_mmap_writable)->counter) *)&((&mapping->i_mmap_writable)->counter); })) > 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mapping_map_writable(struct address_space *mapping)
{
 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
  0 : -1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mapping_unmap_writable(struct address_space *mapping)
{
 atomic_sub(1, &mapping->i_mmap_writable);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mapping_deny_writable(struct address_space *mapping)
{
 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
  0 : -16;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mapping_allow_writable(struct address_space *mapping)
{
 atomic_add(1, &mapping->i_mmap_writable);
}
# 565 "include/linux/fs.h"
struct posix_acl;
# 577 "include/linux/fs.h"
struct inode {
 umode_t i_mode;
 unsigned short i_opflags;
 kuid_t i_uid;
 kgid_t i_gid;
 unsigned int i_flags;


 struct posix_acl *i_acl;
 struct posix_acl *i_default_acl;


 const struct inode_operations *i_op;
 struct super_block *i_sb;
 struct address_space *i_mapping;






 unsigned long i_ino;







 union {
  const unsigned int i_nlink;
  unsigned int __i_nlink;
 };
 dev_t i_rdev;
 loff_t i_size;
 struct timespec i_atime;
 struct timespec i_mtime;
 struct timespec i_ctime;
 spinlock_t i_lock;
 unsigned short i_bytes;
 unsigned int i_blkbits;
 blkcnt_t i_blocks;


 seqcount_t i_size_seqcount;



 unsigned long i_state;
 struct mutex i_mutex;

 unsigned long dirtied_when;

 struct hlist_node i_hash;
 struct list_head i_wb_list;
 struct list_head i_lru;
 struct list_head i_sb_list;
 union {
  struct hlist_head i_dentry;
  struct callback_head i_rcu;
 };
 u64 i_version;
 atomic_t i_count;
 atomic_t i_dio_count;
 atomic_t i_writecount;



 const struct file_operations *i_fop;
 struct file_lock_context *i_flctx;
 struct address_space i_data;
 struct list_head i_devices;
 union {
  struct pipe_inode_info *i_pipe;
  struct block_device *i_bdev;
  struct cdev *i_cdev;
 };

 __u32 i_generation;


 __u32 i_fsnotify_mask;
 struct hlist_head i_fsnotify_marks;


 void *i_private;
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int inode_unhashed(struct inode *inode)
{
 return hlist_unhashed(&inode->i_hash);
}
# 686 "include/linux/fs.h"
enum inode_i_mutex_lock_class
{
 I_MUTEX_NORMAL,
 I_MUTEX_PARENT,
 I_MUTEX_CHILD,
 I_MUTEX_XATTR,
 I_MUTEX_NONDIR2,
 I_MUTEX_PARENT2,
};

void lock_two_nondirectories(struct inode *, struct inode*);
void unlock_two_nondirectories(struct inode *, struct inode*);
# 709 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) loff_t i_size_read(const struct inode *inode)
{

 loff_t i_size;
 unsigned int seq;

 do {
  seq = read_seqcount_begin(&inode->i_size_seqcount);
  i_size = inode->i_size;
 } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
 return i_size;
# 730 "include/linux/fs.h"
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_size_write(struct inode *inode, loff_t i_size)
{

 do { preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
 write_seqcount_begin(&inode->i_size_seqcount);
 inode->i_size = i_size;
 write_seqcount_end(&inode->i_size_seqcount);
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);







}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) uid_t i_uid_read(const struct inode *inode)
{
 return from_kuid(&init_user_ns, inode->i_uid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) gid_t i_gid_read(const struct inode *inode)
{
 return from_kgid(&init_user_ns, inode->i_gid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_uid_write(struct inode *inode, uid_t uid)
{
 inode->i_uid = make_kuid(&init_user_ns, uid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_gid_write(struct inode *inode, gid_t gid)
{
 inode->i_gid = make_kgid(&init_user_ns, gid);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned iminor(const struct inode *inode)
{
 return ((unsigned int) ((inode->i_rdev) & ((1U << 20) - 1)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;
 kuid_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)) __attribute__((no_instrument_function)) 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 llist_node fu_llist;
  struct callback_head fu_rcuhead;
 } f_u;
 struct path f_path;
 struct inode *f_inode;
 const struct file_operations *f_op;





 spinlock_t f_lock;
 atomic_long_t f_count;
 unsigned int f_flags;
 fmode_t f_mode;
 struct mutex f_pos_lock;
 loff_t f_pos;
 struct fown_struct f_owner;
 const struct cred *f_cred;
 struct file_ra_state f_ra;

 u64 f_version;




 void *private_data;



 struct list_head f_ep_links;
 struct list_head f_tfile_llink;

 struct address_space *f_mapping;
} __attribute__((aligned(4)));

struct file_handle {
 __u32 handle_bytes;
 int handle_type;

 unsigned char f_handle[0];
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct file *get_file(struct file *f)
{
 atomic_long_inc(&f->f_count);
 return f;
}
# 906 "include/linux/fs.h"
typedef void *fl_owner_t;

struct file_lock;

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 (*lm_compare_owner)(struct file_lock *, struct file_lock *);
 unsigned long (*lm_owner_key)(struct file_lock *);
 fl_owner_t (*lm_get_owner)(fl_owner_t);
 void (*lm_put_owner)(fl_owner_t);
 void (*lm_notify)(struct file_lock *);
 int (*lm_grant)(struct file_lock *, int);
 bool (*lm_break)(struct file_lock *);
 int (*lm_change)(struct file_lock *, int, struct list_head *);
 void (*lm_setup)(struct file_lock *, void **);
};

struct lock_manager {
 struct list_head list;
};

struct net;
void locks_start_grace(struct net *, struct lock_manager *);
void locks_end_grace(struct lock_manager *);
int locks_in_grace(struct net *);


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



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;
};
# 938 "include/linux/fs.h" 2
# 956 "include/linux/fs.h"
struct file_lock {
 struct file_lock *fl_next;
 struct list_head fl_list;
 struct hlist_node fl_link;
 struct list_head fl_block;
 fl_owner_t fl_owner;
 unsigned int fl_flags;
 unsigned char fl_type;
 unsigned int fl_pid;
 int fl_link_cpu;
 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;
 unsigned long fl_downgrade_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;
};

struct file_lock_context {
 spinlock_t flc_lock;
 struct list_head flc_flock;
 struct list_head flc_posix;
 struct list_head flc_lease;
};
# 1003 "include/linux/fs.h"
# 1 "include/linux/fcntl.h" 1



# 1 "include/uapi/linux/fcntl.h" 1



# 1 "./arch/arm/include/uapi/asm/fcntl.h" 1
# 9 "./arch/arm/include/uapi/asm/fcntl.h"
# 1 "./include/uapi/asm-generic/fcntl.h" 1
# 155 "./include/uapi/asm-generic/fcntl.h"
struct f_owner_ex {
 int type;
 __kernel_pid_t pid;
};
# 195 "./include/uapi/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;

};







struct flock64 {
 short l_type;
 short l_whence;
 __kernel_loff_t l_start;
 __kernel_loff_t l_len;
 __kernel_pid_t l_pid;

};
# 10 "./arch/arm/include/uapi/asm/fcntl.h" 2
# 5 "include/uapi/linux/fcntl.h" 2
# 5 "include/linux/fcntl.h" 2
# 1004 "include/linux/fs.h" 2

extern void send_sigio(struct fown_struct *fown, int fd, int band);


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


extern int fcntl_getlk64(struct file *, unsigned int, 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);


void locks_free_lock_context(struct file_lock_context *ctx);
void locks_free_lock(struct file_lock *fl);
extern void locks_init_lock(struct file_lock *);
extern struct file_lock * locks_alloc_lock(void);
extern void locks_copy_lock(struct file_lock *, struct file_lock *);
extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
extern void locks_remove_posix(struct file *, fl_owner_t);
extern void locks_remove_file(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_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, unsigned int type);
extern void lease_get_mtime(struct inode *, struct timespec *time);
extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
extern int lease_modify(struct file_lock *, int, struct list_head *);
struct files_struct;
extern void show_fd_locks(struct seq_file *f,
    struct file *filp, struct files_struct *files);
# 1190 "include/linux/fs.h"
struct fasync_struct {
 spinlock_t fa_lock;
 int magic;
 int fa_fd;
 struct fasync_struct *fa_next;
 struct file *fa_file;
 struct callback_head fa_rcu;
};




extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
extern int fasync_remove_entry(struct file *, struct fasync_struct **);
extern struct fasync_struct *fasync_alloc(void);
extern void fasync_free(struct fasync_struct *);


extern void kill_fasync(struct fasync_struct **, int, int);

extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
extern void 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);

struct mm_struct;
# 1231 "include/linux/fs.h"
enum {
 SB_UNFROZEN = 0,
 SB_FREEZE_WRITE = 1,
 SB_FREEZE_PAGEFAULT = 2,
 SB_FREEZE_FS = 3,

 SB_FREEZE_COMPLETE = 4,
};



struct sb_writers {

 struct percpu_counter counter[(SB_FREEZE_COMPLETE - 1)];
 wait_queue_head_t wait;

 int frozen;
 wait_queue_head_t wait_unfrozen;




};

struct super_block {
 struct list_head s_list;
 dev_t s_dev;
 unsigned char s_blocksize_bits;
 unsigned long s_blocksize;
 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;
 int s_count;
 atomic_t s_active;



 const struct xattr_handler **s_xattr;

 struct list_head s_inodes;
 struct hlist_bl_head s_anon;
 struct list_head s_mounts;
 struct block_device *s_bdev;
 struct backing_dev_info *s_bdi;
 struct mtd_info *s_mtd;
 struct hlist_node s_instances;
 unsigned int s_quota_types;
 struct quota_info s_dquot;

 struct sb_writers s_writers;

 char s_id[32];
 u8 s_uuid[16];

 void *s_fs_info;
 unsigned int s_max_links;
 fmode_t s_mode;



 u32 s_time_gran;





 struct mutex s_vfs_rename_mutex;





 char *s_subtype;





 char *s_options;
 const struct dentry_operations *s_d_op;




 int cleancache_poolid;

 struct shrinker s_shrink;


 atomic_long_t s_remove_count;


 int s_readonly_remount;


 struct workqueue_struct *s_dio_done_wq;
 struct hlist_head s_pins;





 struct list_lru s_dentry_lru __attribute__((__aligned__((1 << 6))));
 struct list_lru s_inode_lru __attribute__((__aligned__((1 << 6))));
 struct callback_head rcu;




 int s_stack_depth;
};

extern struct timespec current_fs_time(struct super_block *sb);





void __sb_end_write(struct super_block *sb, int level);
int __sb_start_write(struct super_block *sb, int level, bool wait);
# 1366 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sb_end_write(struct super_block *sb)
{
 __sb_end_write(sb, SB_FREEZE_WRITE);
}
# 1378 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sb_end_pagefault(struct super_block *sb)
{
 __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
}
# 1390 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sb_end_intwrite(struct super_block *sb)
{
 __sb_end_write(sb, SB_FREEZE_FS);
}
# 1414 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sb_start_write(struct super_block *sb)
{
 __sb_start_write(sb, SB_FREEZE_WRITE, true);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int sb_start_write_trylock(struct super_block *sb)
{
 return __sb_start_write(sb, SB_FREEZE_WRITE, false);
}
# 1443 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sb_start_pagefault(struct super_block *sb)
{
 __sb_start_write(sb, SB_FREEZE_PAGEFAULT, true);
}
# 1461 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sb_start_intwrite(struct super_block *sb)
{
 __sb_start_write(sb, SB_FREEZE_FS, true);
}


extern bool inode_owner_or_capable(const struct inode *inode);




extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
extern int vfs_symlink(struct inode *, struct dentry *, const char *);
extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
extern int vfs_rmdir(struct inode *, struct dentry *);
extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
extern int vfs_whiteout(struct inode *, struct dentry *);




extern void dentry_unhash(struct dentry *dentry);




extern void inode_init_owner(struct inode *inode, const struct inode *dir,
   umode_t mode);



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);
# 1528 "include/linux/fs.h"
struct dir_context;
typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
    unsigned);

struct dir_context {
 const filldir_t actor;
 loff_t pos;
};

struct block_device_operations;
# 1565 "include/linux/fs.h"
struct iov_iter;

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);
 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
 int (*iterate) (struct file *, struct dir_context *);
 unsigned int (*poll) (struct file *, struct poll_table_struct *);
 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 *);
 void (*mremap)(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 *, loff_t, loff_t, 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 **, void **);
 long (*fallocate)(struct file *file, int mode, loff_t offset,
     loff_t len);
 void (*show_fdinfo)(struct seq_file *m, struct file *f);



};

struct inode_operations {
 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
 void * (*follow_link) (struct dentry *, struct nameidata *);
 int (*permission) (struct inode *, int);
 struct posix_acl * (*get_acl)(struct inode *, int);

 int (*readlink) (struct dentry *, char *,int);
 void (*put_link) (struct dentry *, struct nameidata *, void *);

 int (*create) (struct inode *,struct dentry *, umode_t, bool);
 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 *,umode_t);
 int (*rmdir) (struct inode *,struct dentry *);
 int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
 int (*rename) (struct inode *, struct dentry *,
   struct inode *, struct dentry *);
 int (*rename2) (struct inode *, struct dentry *,
   struct inode *, struct dentry *, unsigned 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 *);
 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
        u64 len);
 int (*update_time)(struct inode *, struct timespec *, int);
 int (*atomic_open)(struct inode *, struct dentry *,
      struct file *, unsigned open_flag,
      umode_t create_mode, int *opened);
 int (*tmpfile) (struct inode *, struct dentry *, umode_t);
 int (*set_acl)(struct inode *, struct posix_acl *, int);


 int (*dentry_open)(struct dentry *, struct file *, const struct cred *);
} __attribute__((__aligned__((1 << 6))));

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_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 flags);
 int (*write_inode) (struct inode *, struct writeback_control *wbc);
 int (*drop_inode) (struct inode *);
 void (*evict_inode) (struct inode *);
 void (*put_super) (struct super_block *);
 int (*sync_fs)(struct super_block *sb, int wait);
 int (*freeze_super) (struct super_block *);
 int (*freeze_fs) (struct super_block *);
 int (*thaw_super) (struct super_block *);
 int (*unfreeze_fs) (struct super_block *);
 int (*statfs) (struct dentry *, struct kstatfs *);
 int (*remount_fs) (struct super_block *, int *, char *);
 void (*umount_begin) (struct super_block *);

 int (*show_options)(struct seq_file *, struct dentry *);
 int (*show_devname)(struct seq_file *, struct dentry *);
 int (*show_path)(struct seq_file *, struct dentry *);
 int (*show_stats)(struct seq_file *, struct dentry *);





 int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
 long (*nr_cached_objects)(struct super_block *,
      struct shrink_control *);
 long (*free_cached_objects)(struct super_block *,
        struct shrink_control *);
};
# 1827 "include/linux/fs.h"
extern void __mark_inode_dirty(struct inode *, int);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mark_inode_dirty(struct inode *inode)
{
 __mark_inode_dirty(inode, ((1 << 0) | (1 << 1) | (1 << 2)));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mark_inode_dirty_sync(struct inode *inode)
{
 __mark_inode_dirty(inode, (1 << 0));
}

extern void inc_nlink(struct inode *inode);
extern void drop_nlink(struct inode *inode);
extern void clear_nlink(struct inode *inode);
extern void set_nlink(struct inode *inode, unsigned int nlink);

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void inode_dec_link_count(struct inode *inode)
{
 drop_nlink(inode);
 mark_inode_dirty(inode);
}
# 1863 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void inode_inc_iversion(struct inode *inode)
{
       spin_lock(&inode->i_lock);
       inode->i_version++;
       spin_unlock(&inode->i_lock);
}

enum file_time_flags {
 S_ATIME = 1,
 S_MTIME = 2,
 S_CTIME = 4,
 S_VERSION = 8,
};

extern void touch_atime(const struct path *);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void file_accessed(struct file *file)
{
 if (!(file->f_flags & 01000000))
  touch_atime(&file->f_path);
}

int sync_inode(struct inode *inode, struct writeback_control *wbc);
int sync_inode_metadata(struct inode *inode, int wait);

struct file_system_type {
 const char *name;
 int fs_flags;






 struct dentry *(*mount) (struct file_system_type *, int,
         const char *, void *);
 void (*kill_sb) (struct super_block *);
 struct module *owner;
 struct file_system_type * next;
 struct hlist_head fs_supers;

 struct lock_class_key s_lock_key;
 struct lock_class_key s_umount_key;
 struct lock_class_key s_vfs_rename_key;
 struct lock_class_key s_writers_key[(SB_FREEZE_COMPLETE - 1)];

 struct lock_class_key i_lock_key;
 struct lock_class_key i_mutex_key;
 struct lock_class_key i_mutex_dir_key;
};



extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
 void *data, int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_bdev(struct file_system_type *fs_type,
 int flags, const char *dev_name, void *data,
 int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_single(struct file_system_type *fs_type,
 int flags, void *data,
 int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_nodev(struct file_system_type *fs_type,
 int flags, void *data,
 int (*fill_super)(struct super_block *, void *, int));
extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
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);
int get_anon_bdev(dev_t *);
void free_anon_bdev(dev_t);
struct super_block *sget(struct file_system_type *type,
   int (*test)(struct super_block *,void *),
   int (*set)(struct super_block *,void *),
   int flags, void *data);
extern struct dentry *mount_pseudo(struct file_system_type *, char *,
 const struct super_operations *ops,
 const struct dentry_operations *dops,
 unsigned long);
# 1962 "include/linux/fs.h"
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 void kern_unmount(struct vfsmount *mnt);
extern int may_umount_tree(struct vfsmount *);
extern int may_umount(struct vfsmount *);
extern long do_mount(const char *, const char *,
       const char *, unsigned long, void *);
extern struct vfsmount *collect_mounts(struct path *);
extern void drop_collected_mounts(struct vfsmount *);
extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
     struct vfsmount *);
extern int vfs_statfs(struct path *, struct kstatfs *);
extern int user_statfs(const char *, struct kstatfs *);
extern int fd_statfs(int, struct kstatfs *);
extern int vfs_ustat(dev_t, struct kstatfs *);
extern int freeze_super(struct super_block *super);
extern int thaw_super(struct super_block *super);
extern bool our_mnt(struct vfsmount *mnt);
extern bool fs_fully_visible(struct file_system_type *);

extern int current_umask(void);

extern void ihold(struct inode * inode);
extern void iput(struct inode *);
extern int generic_update_time(struct inode *, struct timespec *, int);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct inode *file_inode(const struct file *f)
{
 return f->f_inode;
}


extern struct kobject *fs_kobj;







extern int locks_mandatory_locked(struct file *);
extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __mandatory_lock(struct inode *ino)
{
 return (ino->i_mode & (0002000 | 00010)) == 0002000;
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mandatory_lock(struct inode *ino)
{
 return ((ino)->i_sb->s_flags & (64)) && __mandatory_lock(ino);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int locks_verify_locked(struct file *file)
{
 if (mandatory_lock(file_inode(file)))
  return locks_mandatory_locked(file);
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int locks_verify_truncate(struct inode *inode,
        struct file *filp,
        loff_t size)
{
 if (inode->i_flctx && 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)) __attribute__((no_instrument_function)) int break_lease(struct inode *inode, unsigned int mode)
{






 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
  return __break_lease(inode, mode, 32);
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int break_deleg(struct inode *inode, unsigned int mode)
{






 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
  return __break_lease(inode, mode, 4);
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
{
 int ret;

 ret = break_deleg(inode, 00000001|00004000);
 if (ret == -11 && delegated_inode) {
  *delegated_inode = inode;
  ihold(inode);
 }
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int break_deleg_wait(struct inode **delegated_inode)
{
 int ret;

 ret = break_deleg(*delegated_inode, 00000001);
 iput(*delegated_inode);
 *delegated_inode = ((void *)0);
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int break_layout(struct inode *inode, bool wait)
{
 __asm__ __volatile__ ("dmb " "ish" : : : "memory");
 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
  return __break_lease(inode,
    wait ? 00000001 : 00000001 | 00004000,
    2048);
 return 0;
}
# 2171 "include/linux/fs.h"
struct audit_names;
struct filename {
 const char *name;
 const char *uptr;
 struct audit_names *aname;
 int refcnt;
 const char iname[];
};

extern long vfs_truncate(struct path *, loff_t);
extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
         struct file *filp);
extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
   loff_t len);
extern long do_sys_open(int dfd, const char *filename, int flags,
   umode_t mode);
extern struct file *file_open_name(struct filename *, int, umode_t);
extern struct file *filp_open(const char *, int, umode_t);
extern struct file *file_open_root(struct dentry *, struct vfsmount *,
       const char *, int);
extern int vfs_open(const struct path *, struct file *, const struct cred *);
extern struct file * dentry_open(const struct path *, int, const struct cred *);
extern int filp_close(struct file *, fl_owner_t id);

extern struct filename *getname_flags(const char *, int, int *);
extern struct filename *getname(const char *);
extern struct filename *getname_kernel(const char *);
extern void putname(struct filename *name);

enum {
 FILE_CREATED = 1,
 FILE_OPENED = 2
};
extern int finish_open(struct file *file, struct dentry *dentry,
   int (*open)(struct inode *, struct file *),
   int *opened);
extern int finish_no_open(struct file *file, struct dentry *dentry);



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;





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 void invalidate_bdev(struct block_device *);
extern void iterate_bdevs(void (*)(struct block_device *, void *), void *);
extern int sync_blockdev(struct block_device *bdev);
extern void kill_bdev(struct block_device *);
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 *);
extern int sb_is_blkdev_sb(struct super_block *sb);
# 2264 "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 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 *bdev, fmode_t mode, void *holder);
extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
            void *holder);
extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
           void *holder);
extern void blkdev_put(struct block_device *bdev, fmode_t mode);

extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
extern void bd_unlink_disk_holder(struct block_device *bdev,
      struct gendisk *disk);
# 2296 "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)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) 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 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 *);
# 2349 "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 *, bool);
extern int invalidate_partition(struct gendisk *, int);

unsigned long invalidate_mapping_pages(struct address_space *mapping,
     unsigned long start, unsigned long end);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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 __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, loff_t start, loff_t end,
      int datasync);
extern int vfs_fsync(struct file *file, int datasync);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int generic_write_sync(struct file *file, loff_t pos, loff_t count)
{
 if (!(file->f_flags & 00010000) && !(((file->f_mapping->host)->i_sb->s_flags & (16)) || ((file->f_mapping->host)->i_flags & 1)))
  return 0;
 return vfs_fsync_range(file, pos, pos + count - 1,
          (file->f_flags & 04000000) ? 0 : 1);
}
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 *, struct inode **);
extern int inode_permission(struct inode *, int);
extern int __inode_permission(struct inode *, int);
extern int generic_permission(struct inode *, int);
extern int __check_sticky(struct inode *dir, struct inode *inode);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool execute_ok(struct inode *inode)
{
 return (inode->i_mode & (00100|00010|00001)) || (((inode->i_mode) & 00170000) == 0040000);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void file_start_write(struct file *file)
{
 if (!(((file_inode(file)->i_mode) & 00170000) == 0100000))
  return;
 __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool file_start_write_trylock(struct file *file)
{
 if (!(((file_inode(file)->i_mode) & 00170000) == 0100000))
  return true;
 return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void file_end_write(struct file *file)
{
 if (!(((file_inode(file)->i_mode) & 00170000) == 0100000))
  return;
 __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
}
# 2445 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int get_write_access(struct inode *inode)
{
 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -26;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int deny_write_access(struct file *file)
{
 struct inode *inode = file_inode(file);
 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -26;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void put_write_access(struct inode * inode)
{
 atomic_sub(1, &inode->i_writecount);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void allow_write_access(struct file *file)
{
 if (file)
  atomic_add(1, &file_inode(file)->i_writecount);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool inode_is_open_for_write(const struct inode *inode)
{
 return (*({ __attribute__((unused)) typeof((&inode->i_writecount)->counter) __var = ( typeof((&inode->i_writecount)->counter)) 0; (volatile typeof((&inode->i_writecount)->counter) *)&((&inode->i_writecount)->counter); })) > 0;
}
# 2479 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_readcount_dec(struct inode *inode)
{
 return;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void i_readcount_inc(struct inode *inode)
{
 return;
}

extern int do_pipe_flags(int *, int);

extern int kernel_read(struct file *, loff_t, char *, unsigned long);
extern ssize_t kernel_write(struct file *, const char *, size_t, loff_t);
extern ssize_t __kernel_write(struct file *, const char *, size_t, loff_t *);
extern struct file * open_exec(const char *);


extern int is_subdir(struct dentry *, struct dentry *);
extern int path_is_under(struct path *, struct path *);

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






# 1 "arch/arm/include/generated/asm/errno.h" 1
# 8 "include/linux/err.h" 2
# 23 "include/linux/err.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void * __attribute__((warn_unused_result)) ERR_PTR(long error)
{
 return (void *) error;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) long __attribute__((warn_unused_result)) PTR_ERR( const void *ptr)
{
 return (long) ptr;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool __attribute__((warn_unused_result)) IS_ERR( const void *ptr)
{
 return __builtin_expect(!!(((unsigned long)ptr) >= (unsigned long)-4095), 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool __attribute__((warn_unused_result)) IS_ERR_OR_NULL( const void *ptr)
{
 return !ptr || __builtin_expect(!!(((unsigned long)ptr) >= (unsigned long)-4095), 0);
}
# 50 "include/linux/err.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void * __attribute__((warn_unused_result)) ERR_CAST( const void *ptr)
{

 return (void *) ptr;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) PTR_ERR_OR_ZERO( const void *ptr)
{
 if (IS_ERR(ptr))
  return PTR_ERR(ptr);
 else
  return 0;
}
# 2500 "include/linux/fs.h" 2


extern loff_t default_llseek(struct file *file, loff_t offset, int whence);

extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);

extern int inode_init_always(struct super_block *, struct inode *);
extern void inode_init_once(struct inode *);
extern void address_space_init_once(struct address_space *mapping);
extern struct inode * igrab(struct inode *);
extern ino_t iunique(struct super_block *, ino_t);
extern int inode_needs_sync(struct inode *inode);
extern int generic_delete_inode(struct inode *inode);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int generic_drop_inode(struct inode *inode)
{
 return !inode->i_nlink || inode_unhashed(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 struct inode *find_inode_nowait(struct super_block *,
           unsigned long,
           int (*match)(struct inode *,
          unsigned long, void *),
           void *data);
extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
extern int insert_inode_locked(struct inode *);



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void lockdep_annotate_inode_mutex_key(struct inode *inode) { };

extern void unlock_new_inode(struct inode *);
extern unsigned int get_next_ino(void);

extern void __iget(struct inode * inode);
extern void iget_failed(struct inode *);
extern void clear_inode(struct inode *);
extern void __destroy_inode(struct inode *);
extern struct inode *new_inode_pseudo(struct super_block *sb);
extern struct inode *new_inode(struct super_block *sb);
extern void free_inode_nonrcu(struct inode *inode);
extern int should_remove_suid(struct dentry *);
extern int file_remove_suid(struct file *);

extern void __insert_inode_hash(struct inode *, unsigned long hashval);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void insert_inode_hash(struct inode *inode)
{
 __insert_inode_hash(inode, inode->i_ino);
}

extern void __remove_inode_hash(struct inode *);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void remove_inode_hash(struct inode *inode)
{
 if (!inode_unhashed(inode))
  __remove_inode_hash(inode);
}

extern void inode_sb_list_add(struct inode *inode);


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 *);
int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *, loff_t);
extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
extern ssize_t do_sync_read(struct file *filp, char *buf, size_t len, loff_t *ppos);
extern ssize_t do_sync_write(struct file *filp, const char *buf, size_t len, loff_t *ppos);
extern ssize_t new_sync_read(struct file *filp, char *buf, size_t len, loff_t *ppos);
extern ssize_t new_sync_write(struct file *filp, const char *buf, size_t len, loff_t *ppos);

ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos);
ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos);


extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to);
extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from);
extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
   int datasync);
extern void block_sync_page(struct page *page);


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 iter_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,
  loff_t *opos, size_t len, unsigned int flags);


extern void
file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
  int whence, loff_t maxsize, loff_t eof);
extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
  int whence, loff_t size);
extern int generic_file_open(struct inode * inode, struct file * filp);
extern int nonseekable_open(struct inode * inode, struct file * filp);

ssize_t dax_do_io(int rw, struct kiocb *, struct inode *, struct iov_iter *,
  loff_t, get_block_t, dio_iodone_t, int flags);
int dax_clear_blocks(struct inode *, sector_t block, long size);
int dax_zero_page_range(struct inode *, loff_t from, unsigned len, get_block_t);
int dax_truncate_page(struct inode *, loff_t from, get_block_t);
int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t);



typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
       loff_t file_offset);

enum {

 DIO_LOCKING = 0x01,


 DIO_SKIP_HOLES = 0x02,


 DIO_ASYNC_EXTEND = 0x04,
};

void dio_end_io(struct bio *bio, int error);

ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 struct block_device *bdev, struct iov_iter *iter, loff_t offset,
 get_block_t get_block, dio_iodone_t end_io,
 dio_submit_t submit_io, int flags);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
  struct inode *inode, struct iov_iter *iter, loff_t offset,
  get_block_t get_block)
{
 return __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iter,
        offset, get_block, ((void *)0), ((void *)0),
        DIO_LOCKING | DIO_SKIP_HOLES);
}


void inode_dio_wait(struct inode *inode);
void inode_dio_done(struct inode *inode);

extern void inode_set_flags(struct inode *inode, unsigned int flags,
       unsigned int mask);

extern const struct file_operations generic_ro_fops;



extern int readlink_copy(char *, int, 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 void kfree_put_link(struct dentry *, struct nameidata *, void *);
extern int generic_readlink(struct dentry *, char *, int);
extern void generic_fillattr(struct inode *, struct kstat *);
int vfs_getattr_nosec(struct path *path, struct kstat *stat);
extern int vfs_getattr(struct path *, struct kstat *);
void __inode_add_bytes(struct inode *inode, loff_t bytes);
void inode_add_bytes(struct inode *inode, loff_t bytes);
void __inode_sub_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 iterate_dir(struct file *, struct dir_context *);

extern int vfs_stat(const char *, struct kstat *);
extern int vfs_lstat(const char *, struct kstat *);
extern int vfs_fstat(unsigned int, struct kstat *);
extern int vfs_fstatat(int , const 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,
      loff_t start, loff_t 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_super_thawed(struct block_device *);
extern struct super_block *get_active_super(struct block_device *bdev);
extern void drop_super(struct super_block *sb);
extern void iterate_supers(void (*)(struct super_block *, void *), void *);
extern void iterate_supers_type(struct file_system_type *,
           void (*)(struct super_block *, void *), void *);

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 *, struct dir_context *);
extern int simple_setattr(struct dentry *, struct iattr *);
extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
extern int simple_statfs(struct dentry *, struct kstatfs *);
extern int simple_open(struct inode *inode, struct file *file);
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 noop_fsync(struct file *, loff_t, loff_t, int);
extern int simple_empty(struct dentry *);
extern int simple_readpage(struct file *file, struct page *page);
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 int always_delete_dentry(const struct dentry *);
extern struct inode *alloc_anon_inode(struct super_block *);
extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
extern const struct dentry_operations simple_dentry_operations;

extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
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 *, unsigned long, 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 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
  const void *from, size_t count);

extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
extern int generic_file_fsync(struct file *, loff_t, loff_t, int);

extern int generic_check_addressable(unsigned, u64);


extern int buffer_migrate_page(struct address_space *,
    struct page *, struct page *,
    enum migrate_mode);




extern int inode_change_ok(const struct inode *, struct iattr *);
extern int inode_newsize_ok(const struct inode *, loff_t offset);
extern void setattr_copy(struct inode *inode, const struct iattr *attr);

extern int file_update_time(struct file *file);

extern int generic_show_options(struct seq_file *m, struct dentry *root);
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)) __attribute__((no_instrument_function)) bool io_is_direct(struct file *filp)
{
 return (filp->f_flags & 0200000) || ((file_inode(filp))->i_flags & 0);
}

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





 spin_lock(&dentry->d_lockref.lock);
 res = dentry->d_parent->d_inode->i_ino;
 spin_unlock(&dentry->d_lockref.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);
# 2857 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((format(printf, 1, 2)))
void __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 proc_nr_dentry(struct ctl_table *table, int write,
    void *buffer, size_t *lenp, loff_t *ppos);
int proc_nr_inodes(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);
# 2888 "include/linux/fs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_sxid(umode_t mode)
{
 return (mode & 0004000) || ((mode & 0002000) && (mode & 00010));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int check_sticky(struct inode *dir, struct inode *inode)
{
 if (!(dir->i_mode & 0001000))
  return 0;

 return __check_sticky(dir, inode);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void inode_has_no_xattr(struct inode *inode)
{
 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & (1<<28)))
  inode->i_flags |= 4096;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool is_root_inode(struct inode *inode)
{
 return inode == inode->i_sb->s_root->d_inode;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool dir_emit(struct dir_context *ctx,
       const char *name, int namelen,
       u64 ino, unsigned type)
{
 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool dir_emit_dot(struct file *file, struct dir_context *ctx)
{
 return ctx->actor(ctx, ".", 1, ctx->pos,
     file->f_path.dentry->d_inode->i_ino, 4) == 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
{
 return ctx->actor(ctx, "..", 2, ctx->pos,
     parent_ino(file->f_path.dentry), 4) == 0;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool dir_emit_dots(struct file *file, struct dir_context *ctx)
{
 if (ctx->pos == 0) {
  if (!dir_emit_dot(file, ctx))
   return false;
  ctx->pos = 1;
 }
 if (ctx->pos == 1) {
  if (!dir_emit_dotdot(file, ctx))
   return false;
  ctx->pos = 2;
 }
 return true;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool dir_relax(struct inode *inode)
{
 mutex_unlock(&inode->i_mutex);
 mutex_lock(&inode->i_mutex);
 return !((inode)->i_flags & 16);
}
# 9 "include/linux/pagemap.h" 2

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







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




# 1 "./arch/arm/include/asm/uaccess.h" 1
# 16 "./arch/arm/include/asm/uaccess.h"
# 1 "arch/arm/include/generated/asm/errno.h" 1
# 17 "./arch/arm/include/asm/uaccess.h" 2
# 45 "./arch/arm/include/asm/uaccess.h"
struct exception_table_entry
{
 unsigned long insn, fixup;
};

extern int fixup_exception(struct pt_regs *regs);





extern int __get_user_bad(void);
extern int __put_user_bad(void);
# 70 "./arch/arm/include/asm/uaccess.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_fs(mm_segment_t fs)
{
 current_thread_info()->addr_limit = fs;
 modify_domain(0, fs ? 1 : 1);
}
# 107 "./arch/arm/include/asm/uaccess.h"
extern int __get_user_1(void *);
extern int __get_user_2(void *);
extern int __get_user_4(void *);
extern int __get_user_32t_8(void *);
extern int __get_user_8(void *);
extern int __get_user_64t_1(void *);
extern int __get_user_64t_2(void *);
extern int __get_user_64t_4(void *);
# 205 "./arch/arm/include/asm/uaccess.h"
extern int __put_user_1(void *, unsigned int);
extern int __put_user_2(void *, unsigned int);
extern int __put_user_4(void *, unsigned int);
extern int __put_user_8(void *, unsigned long long);
# 477 "./arch/arm/include/asm/uaccess.h"
extern unsigned long __attribute__((warn_unused_result)) __copy_from_user(void *to, const void *from, unsigned long n);
extern unsigned long __attribute__((warn_unused_result)) __copy_to_user(void *to, const void *from, unsigned long n);
extern unsigned long __attribute__((warn_unused_result)) __copy_to_user_std(void *to, const void *from, unsigned long n);
extern unsigned long __attribute__((warn_unused_result)) __clear_user(void *addr, unsigned long n);
extern unsigned long __attribute__((warn_unused_result)) __clear_user_std(void *addr, unsigned long n);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __attribute__((warn_unused_result)) copy_from_user(void *to, const void *from, unsigned long n)
{
 if ((({ unsigned long flag, roksum; (void)0; __asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" : "=&r" (flag), "=&r" (roksum) : "r" (from), "Ir" (n), "0" (current_thread_info()->addr_limit) : "cc"); flag; }) == 0))
  n = __copy_from_user(to, from, n);
 else
  ({ void *__p = (to); size_t __n = n; if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });
 return n;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __attribute__((warn_unused_result)) copy_to_user(void *to, const void *from, unsigned long n)
{
 if ((({ unsigned long flag, roksum; (void)0; __asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" : "=&r" (flag), "=&r" (roksum) : "r" (to), "Ir" (n), "0" (current_thread_info()->addr_limit) : "cc"); flag; }) == 0))
  n = __copy_to_user(to, from, n);
 return n;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long __attribute__((warn_unused_result)) clear_user(void *to, unsigned long n)
{
 if ((({ unsigned long flag, roksum; (void)0; __asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" : "=&r" (flag), "=&r" (roksum) : "r" (to), "Ir" (n), "0" (current_thread_info()->addr_limit) : "cc"); flag; }) == 0))
  n = __clear_user(to, n);
 return n;
}

extern long strncpy_from_user(char *dest, const char *src, long count);

extern __attribute__((warn_unused_result)) long strlen_user(const char *str);
extern __attribute__((warn_unused_result)) long strnlen_user(const char *str, long n);
# 6 "include/linux/uaccess.h" 2
# 16 "include/linux/uaccess.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pagefault_disable(void)
{
 preempt_count_add(1);




 __asm__ __volatile__("": : :"memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pagefault_enable(void)
{
# 36 "include/linux/uaccess.h"
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);

}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) unsigned long __copy_from_user_nocache(void *to,
    const void *from, unsigned long n)
{
 return __copy_from_user(to, from, n);
}
# 95 "include/linux/uaccess.h"
extern long probe_kernel_read(void *dst, const void *src, size_t size);
extern long __probe_kernel_read(void *dst, const void *src, size_t size);
# 107 "include/linux/uaccess.h"
extern long __attribute__((no_instrument_function)) probe_kernel_write(void *dst, const void *src, size_t size);
extern long __attribute__((no_instrument_function)) __probe_kernel_write(void *dst, const void *src, size_t size);
# 9 "include/linux/highmem.h" 2
# 1 "include/linux/hardirq.h" 1





# 1 "include/linux/ftrace_irq.h" 1
# 9 "include/linux/ftrace_irq.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ftrace_nmi_enter(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ftrace_nmi_exit(void) { }
# 7 "include/linux/hardirq.h" 2
# 1 "include/linux/vtime.h" 1



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




# 1 "include/linux/static_key.h" 1
# 1 "include/linux/jump_label.h" 1
# 52 "include/linux/jump_label.h"
extern bool static_key_initialized;
# 72 "include/linux/jump_label.h"
struct static_key {
 atomic_t enabled;
};


enum jump_label_type {
 JUMP_LABEL_DISABLE = 0,
 JUMP_LABEL_ENABLE,
};

struct module;



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int static_key_count(struct static_key *key)
{
 return (*({ __attribute__((unused)) typeof((&key->enabled)->counter) __var = ( typeof((&key->enabled)->counter)) 0; (volatile typeof((&key->enabled)->counter) *)&((&key->enabled)->counter); }));
}
# 146 "include/linux/jump_label.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) void jump_label_init(void)
{
 static_key_initialized = true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) bool static_key_false(struct static_key *key)
{
 if (__builtin_expect(!!(static_key_count(key) > 0), 0))
  return true;
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) __attribute__((always_inline)) bool static_key_true(struct static_key *key)
{
 if (__builtin_expect(!!(static_key_count(key) > 0), 1))
  return true;
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void static_key_slow_inc(struct static_key *key)
{
 ({ int __ret_warn_on = !!(!static_key_initialized); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_fmt("include/linux/jump_label.h", 167, "%s used before call to jump_label_init", __func__); __builtin_expect(!!(__ret_warn_on), 0); });
 atomic_add(1, &key->enabled);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void static_key_slow_dec(struct static_key *key)
{
 ({ int __ret_warn_on = !!(!static_key_initialized); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_fmt("include/linux/jump_label.h", 173, "%s used before call to jump_label_init", __func__); __builtin_expect(!!(__ret_warn_on), 0); });
 atomic_sub(1, &key->enabled);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int jump_label_text_reserved(void *start, void *end)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void jump_label_lock(void) {}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void jump_label_unlock(void) {}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int jump_label_apply_nops(struct module *mod)
{
 return 0;
}
# 200 "include/linux/jump_label.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool static_key_enabled(struct static_key *key)
{
 return static_key_count(key) > 0;
}
# 1 "include/linux/static_key.h" 2
# 6 "include/linux/context_tracking_state.h" 2

struct context_tracking {






 bool active;
 enum ctx_state {
  CONTEXT_KERNEL = 0,
  CONTEXT_USER,
  CONTEXT_GUEST,
 } state;
};
# 41 "include/linux/context_tracking_state.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool context_tracking_in_user(void) { return false; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool context_tracking_active(void) { return false; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool context_tracking_is_enabled(void) { return false; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool context_tracking_cpu_is_enabled(void) { return false; }
# 5 "include/linux/vtime.h" 2





struct task_struct;
# 32 "include/linux/vtime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool vtime_accounting_enabled(void) { return false; }
# 69 "include/linux/vtime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_task_switch(struct task_struct *prev) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_account_system(struct task_struct *tsk) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_account_user(struct task_struct *tsk) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_account_irq_enter(struct task_struct *tsk) { }
# 95 "include/linux/vtime.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_account_irq_exit(struct task_struct *tsk)
{

 vtime_account_system(tsk);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_user_enter(struct task_struct *tsk) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_user_exit(struct task_struct *tsk) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_guest_enter(struct task_struct *tsk) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_guest_exit(struct task_struct *tsk) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vtime_init_idle(struct task_struct *tsk, int cpu) { }





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void irqtime_account_irq(struct task_struct *tsk) { }


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void account_irq_enter_time(struct task_struct *tsk)
{
 vtime_account_irq_enter(tsk);
 irqtime_account_irq(tsk);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void account_irq_exit_time(struct task_struct *tsk)
{
 vtime_account_irq_exit(tsk);
 irqtime_account_irq(tsk);
}
# 8 "include/linux/hardirq.h" 2
# 1 "./arch/arm/include/asm/hardirq.h" 1





# 1 "./arch/arm/include/asm/irq.h" 1
# 25 "./arch/arm/include/asm/irq.h"
struct irqaction;
struct pt_regs;
extern void migrate_irqs(void);

extern void asm_do_IRQ(unsigned int, struct pt_regs *);
void handle_IRQ(unsigned int, struct pt_regs *);
void init_IRQ(void);


extern void (*handle_arch_irq)(struct pt_regs *);
extern void set_handle_irq(void (*handle_irq)(struct pt_regs *));
# 7 "./arch/arm/include/asm/hardirq.h" 2



typedef struct {
 unsigned int __softirq_pending;

 unsigned int ipi_irqs[8];

} __attribute__((__aligned__((1 << 6)))) irq_cpustat_t;

# 1 "include/linux/irq_cpustat.h" 1
# 20 "include/linux/irq_cpustat.h"
extern irq_cpustat_t irq_stat[];
# 18 "./arch/arm/include/asm/hardirq.h" 2





u64 smp_irq_stat_cpu(unsigned int cpu);
# 9 "include/linux/hardirq.h" 2


extern void synchronize_irq(unsigned int irq);
extern bool synchronize_hardirq(unsigned int irq);
# 25 "include/linux/hardirq.h"
extern void rcu_nmi_enter(void);
extern void rcu_nmi_exit(void);
# 45 "include/linux/hardirq.h"
extern void irq_enter(void);
# 60 "include/linux/hardirq.h"
extern void irq_exit(void);
# 10 "include/linux/highmem.h" 2

# 1 "./arch/arm/include/asm/cacheflush.h" 1
# 15 "./arch/arm/include/asm/cacheflush.h"
# 1 "./arch/arm/include/asm/glue-cache.h" 1
# 13 "./arch/arm/include/asm/glue-cache.h"
# 1 "./arch/arm/include/asm/glue.h" 1
# 14 "./arch/arm/include/asm/glue-cache.h" 2
# 133 "./arch/arm/include/asm/glue-cache.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_flush_icache_all(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_flush_kern_cache_all(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_flush_kern_cache_louis(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_flush_user_cache_all(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_flush_user_cache_range(unsigned long a,
  unsigned long b, unsigned int c) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_coherent_kern_range(unsigned long a, unsigned long b) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int nop_coherent_user_range(unsigned long a,
  unsigned long b) { return 0; }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_flush_kern_dcache_area(void *a, size_t s) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_dma_flush_range(const void *a, const void *b) { }

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_dma_map_area(const void *s, size_t l, int f) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void nop_dma_unmap_area(const void *s, size_t l, int f) { }
# 16 "./arch/arm/include/asm/cacheflush.h" 2

# 1 "./arch/arm/include/asm/cachetype.h" 1
# 12 "./arch/arm/include/asm/cachetype.h"
extern unsigned int cacheid;
# 53 "./arch/arm/include/asm/cachetype.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned int __attribute__((pure)) cacheid_is(unsigned int mask)
{
 return ((0) & mask) |
        (~((1 << 0)) & ((1 << 1) | (1 << 3) | (1 << 4) | (1 << 5)) & mask & cacheid);
}
# 18 "./arch/arm/include/asm/cacheflush.h" 2
# 104 "./arch/arm/include/asm/cacheflush.h"
struct cpu_cache_fns {
 void (*flush_icache_all)(void);
 void (*flush_kern_all)(void);
 void (*flush_kern_louis)(void);
 void (*flush_user_all)(void);
 void (*flush_user_range)(unsigned long, unsigned long, unsigned int);

 void (*coherent_kern_range)(unsigned long, unsigned long);
 int (*coherent_user_range)(unsigned long, unsigned long);
 void (*flush_kern_dcache_area)(void *, size_t);

 void (*dma_map_area)(const void *, size_t, int);
 void (*dma_unmap_area)(const void *, size_t, int);

 void (*dma_flush_range)(const void *, const void *);
};
# 149 "./arch/arm/include/asm/cacheflush.h"
extern void v7_flush_icache_all(void);
extern void v7_flush_kern_cache_all(void);
extern void v7_flush_kern_cache_louis(void);
extern void v7_flush_user_cache_all(void);
extern void v7_flush_user_cache_range(unsigned long, unsigned long, unsigned int);
extern void v7_coherent_kern_range(unsigned long, unsigned long);
extern int v7_coherent_user_range(unsigned long, unsigned long);
extern void v7_flush_kern_dcache_area(void *, size_t);







extern void v7_dma_map_area(const void *, size_t, int);
extern void v7_dma_unmap_area(const void *, size_t, int);
extern void v7_dma_flush_range(const void *, const void *);
# 175 "./arch/arm/include/asm/cacheflush.h"
extern void copy_to_user_page(struct vm_area_struct *, struct page *,
 unsigned long, void *, const void *, unsigned long);
# 212 "./arch/arm/include/asm/cacheflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __flush_icache_all(void)
{
 v7_flush_icache_all();
 __asm__ __volatile__ ("dsb " "ishst" : : : "memory");
}
# 225 "./arch/arm/include/asm/cacheflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void vivt_flush_cache_mm(struct mm_struct *mm)
{
 if (test_bit(cpumask_check(debug_smp_processor_id()), (((mm_cpumask(mm)))->bits)))
  v7_flush_user_cache_all();
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
vivt_flush_cache_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
{
 struct mm_struct *mm = vma->vm_mm;

 if (!mm || test_bit(cpumask_check(debug_smp_processor_id()), (((mm_cpumask(mm)))->bits)))
  v7_flush_user_cache_range(start & (~((1 << 12) - 1)), ((((end)) + ((typeof((end)))((((1UL) << 12))) - 1)) & ~((typeof((end)))((((1UL) << 12))) - 1)),
     vma->vm_flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
vivt_flush_cache_page(struct vm_area_struct *vma, unsigned long user_addr, unsigned long pfn)
{
 struct mm_struct *mm = vma->vm_mm;

 if (!mm || test_bit(cpumask_check(debug_smp_processor_id()), (((mm_cpumask(mm)))->bits))) {
  unsigned long addr = user_addr & (~((1 << 12) - 1));
  v7_flush_user_cache_range(addr, addr + ((1UL) << 12), vma->vm_flags);
 }
}
# 260 "./arch/arm/include/asm/cacheflush.h"
extern void flush_cache_mm(struct mm_struct *mm);
extern void flush_cache_range(struct vm_area_struct *vma, unsigned long start, unsigned long end);
extern void flush_cache_page(struct vm_area_struct *vma, unsigned long user_addr, unsigned long pfn);
# 299 "./arch/arm/include/asm/cacheflush.h"
extern void flush_dcache_page(struct page *);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void flush_kernel_vmap_range(void *addr, int size)
{
 if ((cacheid_is((1 << 0)) || cacheid_is((1 << 2))))
   v7_flush_kern_dcache_area(addr, (size_t)size);
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void invalidate_kernel_vmap_range(void *addr, int size)
{
 if ((cacheid_is((1 << 0)) || cacheid_is((1 << 2))))
   v7_flush_kern_dcache_area(addr, (size_t)size);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void flush_anon_page(struct vm_area_struct *vma,
    struct page *page, unsigned long vmaddr)
{
 extern void __flush_anon_page(struct vm_area_struct *vma,
    struct page *, unsigned long);
 if (PageAnon(page))
  __flush_anon_page(vma, page, vmaddr);
}


extern void flush_kernel_dcache_page(struct page *);
# 346 "./arch/arm/include/asm/cacheflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void flush_cache_vmap(unsigned long start, unsigned long end)
{
 if (!cacheid_is((1 << 1)))
  v7_flush_kern_cache_all();
 else




  __asm__ __volatile__ ("dsb " "ishst" : : : "memory");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void flush_cache_vunmap(unsigned long start, unsigned long end)
{
 if (!cacheid_is((1 << 1)))
  v7_flush_kern_cache_all();
}
# 401 "./arch/arm/include/asm/cacheflush.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __sync_cache_range_w(volatile void *p, size_t size)
{
 char *_p = (char *)p;

 v7_flush_kern_dcache_area(_p, size);
 outer_clean_range(__virt_to_phys((unsigned long)(_p)), __virt_to_phys((unsigned long)(_p + size)));
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void __sync_cache_range_r(volatile void *p, size_t size)
{
 char *_p = (char *)p;


 if (outer_cache.flush_range) {




  v7_flush_kern_dcache_area(_p, size);


  outer_flush_range(__virt_to_phys((unsigned long)(_p)), __virt_to_phys((unsigned long)(_p + size)));
 }



 v7_flush_kern_dcache_area(_p, size);
}
# 485 "./arch/arm/include/asm/cacheflush.h"
int set_memory_ro(unsigned long addr, int numpages);
int set_memory_rw(unsigned long addr, int numpages);
int set_memory_x(unsigned long addr, int numpages);
int set_memory_nx(unsigned long addr, int numpages);






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_kernel_text_rw(void) { }
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void set_kernel_text_ro(void) { }


void flush_uprobe_xol_access(struct page *page, unsigned long uaddr,
        void *kaddr, unsigned long len);
# 12 "include/linux/highmem.h" 2
# 31 "include/linux/highmem.h"
# 1 "./arch/arm/include/asm/kmap_types.h" 1
# 32 "include/linux/highmem.h" 2


# 1 "./arch/arm/include/asm/highmem.h" 1
# 20 "./arch/arm/include/asm/highmem.h"
extern pte_t *pkmap_page_table;
extern pte_t *fixmap_page_table;

extern void *kmap_high(struct page *page);
extern void kunmap_high(struct page *page);
# 53 "./arch/arm/include/asm/highmem.h"
extern void *kmap_high_get(struct page *page);
# 66 "./arch/arm/include/asm/highmem.h"
extern void *kmap(struct page *page);
extern void kunmap(struct page *page);
extern void *kmap_atomic(struct page *page);
extern void __kunmap_atomic(void *kvaddr);
extern void *kmap_atomic_pfn(unsigned long pfn);
extern struct page *kmap_atomic_to_page(const void *ptr);
# 35 "include/linux/highmem.h" 2


unsigned int nr_free_highpages(void);
extern unsigned long totalhigh_pages;

void kmap_flush_unused(void);

struct page *kmap_to_page(void *addr);
# 88 "include/linux/highmem.h"
extern __attribute__((section(".data..percpu" ""))) __typeof__(int) __kmap_atomic_idx;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kmap_atomic_idx_push(void)
{
 int idx = ({ __this_cpu_preempt_check("add_return"); ({ typeof(__kmap_atomic_idx) pscr2_ret__; do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: pscr2_ret__ = ({ do { do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; default: __bad_size_call_parameter();break; } } while (0); ({ typeof(__kmap_atomic_idx) pscr_ret__; do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 2: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 4: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 8: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }); break; case 2: pscr2_ret__ = ({ do { do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; default: __bad_size_call_parameter();break; } } while (0); ({ typeof(__kmap_atomic_idx) pscr_ret__; do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 2: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 4: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 8: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }); break; case 4: pscr2_ret__ = ({ do { do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; default: __bad_size_call_parameter();break; } } while (0); ({ typeof(__kmap_atomic_idx) pscr_ret__; do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 2: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 4: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 8: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }); break; case 8: pscr2_ret__ = ({ do { do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; } while (0);break; default: __bad_size_call_parameter();break; } } while (0); ({ typeof(__kmap_atomic_idx) pscr_ret__; do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 2: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 4: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 8: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }); break; default: __bad_size_call_parameter(); break; } pscr2_ret__; }); }) - 1;





 return idx;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kmap_atomic_idx(void)
{
 return ({ __this_cpu_preempt_check("read"); ({ typeof(__kmap_atomic_idx) pscr_ret__; do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 2: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 4: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; case 8: pscr_ret__ = (*({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); })); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }) - 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kmap_atomic_idx_pop(void)
{





 ({ __this_cpu_preempt_check("add"); do { do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(__kmap_atomic_idx)) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(__kmap_atomic_idx))(1); } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(__kmap_atomic_idx))(1); } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(__kmap_atomic_idx))(1); } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(__kmap_atomic_idx)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))); (typeof((typeof(*(&(__kmap_atomic_idx))) *)(&(__kmap_atomic_idx)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(__kmap_atomic_idx))(1); } while (0);break; default: __bad_size_call_parameter();break; } } while (0); });

}
# 155 "include/linux/highmem.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *
__alloc_zeroed_user_highpage(gfp_t movableflags,
   struct vm_area_struct *vma,
   unsigned long vaddr)
{
 struct page *page = alloc_pages_node(numa_node_id(), (((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u) | (( gfp_t)0x20000u)) | (( gfp_t)0x02u)) | movableflags, 0)
              ;

 if (page)
  cpu_user.cpu_clear_user_highpage(page, vaddr);

 return page;
}
# 178 "include/linux/highmem.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void clear_highpage(struct page *page)
{
 void *kaddr = kmap_atomic(page);
 ({ void *__p = ((void *)(kaddr)); size_t __n = ((1UL) << 12); if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });
 do { do { bool __cond = !(!(__builtin_types_compatible_p(typeof((kaddr)), typeof(struct page *)))); extern void __compiletime_assert_189(void) __attribute__((error("BUILD_BUG_ON failed: " "__same_type((kaddr), struct page *)"))); if (__cond) __compiletime_assert_189(); do { } while (0); } while (0); __kunmap_atomic(kaddr); } while (0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void zero_user_segments(struct page *page,
 unsigned start1, unsigned end1,
 unsigned start2, unsigned end2)
{
 void *kaddr = kmap_atomic(page);

 do { if (__builtin_expect(!!(end1 > ((1UL) << 12) || end2 > ((1UL) << 12)), 0)) do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/highmem.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "198" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0); } while (0);

 if (end1 > start1)
  ({ void *__p = (kaddr + start1); size_t __n = end1 - start1; if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });

 if (end2 > start2)
  ({ void *__p = (kaddr + start2); size_t __n = end2 - start2; if ((__n) != 0) { if (__builtin_constant_p((0)) && (0) == 0) __memzero((__p),(__n)); else memset((__p),(0),(__n)); } (__p); });

 do { do { bool __cond = !(!(__builtin_types_compatible_p(typeof((kaddr)), typeof(struct page *)))); extern void __compiletime_assert_206(void) __attribute__((error("BUILD_BUG_ON failed: " "__same_type((kaddr), struct page *)"))); if (__cond) __compiletime_assert_206(); do { } while (0); } while (0); __kunmap_atomic(kaddr); } while (0);
 flush_dcache_page(page);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void zero_user_segment(struct page *page,
 unsigned start, unsigned end)
{
 zero_user_segments(page, start, end, 0, 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void zero_user(struct page *page,
 unsigned start, unsigned size)
{
 zero_user_segments(page, start, start + size, 0, 0);
}
# 238 "include/linux/highmem.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void copy_highpage(struct page *to, struct page *from)
{
 char *vfrom, *vto;

 vfrom = kmap_atomic(from);
 vto = kmap_atomic(to);
 copy_page(vto, vfrom);
 do { do { bool __cond = !(!(__builtin_types_compatible_p(typeof((vto)), typeof(struct page *)))); extern void __compiletime_assert_245(void) __attribute__((error("BUILD_BUG_ON failed: " "__same_type((vto), struct page *)"))); if (__cond) __compiletime_assert_245(); do { } while (0); } while (0); __kunmap_atomic(vto); } while (0);
 do { do { bool __cond = !(!(__builtin_types_compatible_p(typeof((vfrom)), typeof(struct page *)))); extern void __compiletime_assert_246(void) __attribute__((error("BUILD_BUG_ON failed: " "__same_type((vfrom), struct page *)"))); if (__cond) __compiletime_assert_246(); do { } while (0); } while (0); __kunmap_atomic(vfrom); } while (0);
}
# 11 "include/linux/pagemap.h" 2





# 1 "include/linux/hugetlb_inline.h" 1
# 15 "include/linux/hugetlb_inline.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int is_vm_hugetlb_page(struct vm_area_struct *vma)
{
 return 0;
}
# 17 "include/linux/pagemap.h" 2





enum mapping_flags {
 AS_EIO = 25 + 0,
 AS_ENOSPC = 25 + 1,
 AS_MM_ALL_LOCKS = 25 + 2,
 AS_UNEVICTABLE = 25 + 3,
 AS_EXITING = 25 + 4,
};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) void mapping_set_unevictable(struct address_space *mapping)
{
 _set_bit(AS_UNEVICTABLE,&mapping->flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mapping_clear_unevictable(struct address_space *mapping)
{
 _clear_bit(AS_UNEVICTABLE,&mapping->flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mapping_unevictable(struct address_space *mapping)
{
 if (mapping)
  return test_bit(AS_UNEVICTABLE, &mapping->flags);
 return !!mapping;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mapping_set_exiting(struct address_space *mapping)
{
 _set_bit(AS_EXITING,&mapping->flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mapping_exiting(struct address_space *mapping)
{
 return test_bit(AS_EXITING, &mapping->flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) gfp_t mapping_gfp_mask(struct address_space * mapping)
{
 return ( gfp_t)mapping->flags & (( gfp_t)((1 << 25) - 1));
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
{
 m->flags = (m->flags & ~( unsigned long)(( gfp_t)((1 << 25) - 1))) |
    ( unsigned long)mask;
}
# 97 "include/linux/pagemap.h"
void release_pages(struct page **pages, int nr, bool cold);
# 143 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_cache_get_speculative(struct page *page)
{
 ((void)(sizeof(( long)(((preempt_count() & ((((1UL << (4))-1) << ((0 + 8) + 8)) | (((1UL << (8))-1) << (0 + 8)) | (((1UL << (1))-1) << (((0 + 8) + 8) + 4)))))))));
# 164 "include/linux/pagemap.h"
 if (__builtin_expect(!!(!get_page_unless_zero(page)), 0)) {





  return 0;
 }

 ((void)(sizeof(( long)(PageTail(page)))));

 return 1;
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_cache_add_speculative(struct page *page, int count)
{
 ((void)(sizeof(( long)(((preempt_count() & ((((1UL << (4))-1) << ((0 + 8) + 8)) | (((1UL << (8))-1) << (0 + 8)) | (((1UL << (1))-1) << (((0 + 8) + 8) + 4)))))))));
# 193 "include/linux/pagemap.h"
 if (__builtin_expect(!!(!atomic_add_unless(&page->_count, count, 0)), 0))
  return 0;

 ((void)(sizeof(( long)(PageCompound(page) && page != compound_head(page)))));

 return 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int page_freeze_refs(struct page *page, int count)
{
 return __builtin_expect(!!(atomic_cmpxchg(&page->_count, count, 0) == count), 1);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void page_unfreeze_refs(struct page *page, int count)
{
 ((void)(sizeof(( long)(page_count(page) != 0))));
 ((void)(sizeof(( long)(count == 0))));

 (((&page->_count)->counter) = (count));
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *__page_cache_alloc(gfp_t gfp)
{
 return alloc_pages_node(numa_node_id(), gfp, 0);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *page_cache_alloc(struct address_space *x)
{
 return __page_cache_alloc(mapping_gfp_mask(x));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *page_cache_alloc_cold(struct address_space *x)
{
 return __page_cache_alloc(mapping_gfp_mask(x)|(( gfp_t)0x100u));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *page_cache_alloc_readahead(struct address_space *x)
{
 return __page_cache_alloc(mapping_gfp_mask(x) |
      (( gfp_t)0x100u) | (( gfp_t)0x1000u) | (( gfp_t)0x200u));
}

typedef int filler_t(void *, struct page *);

unsigned long page_cache_next_hole(struct address_space *mapping,
        unsigned long index, unsigned long max_scan);
unsigned long page_cache_prev_hole(struct address_space *mapping,
        unsigned long index, unsigned long max_scan);
# 253 "include/linux/pagemap.h"
struct page *pagecache_get_page(struct address_space *mapping, unsigned long offset,
  int fgp_flags, gfp_t cache_gfp_mask);
# 266 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *find_get_page(struct address_space *mapping,
     unsigned long offset)
{
 return pagecache_get_page(mapping, offset, 0, 0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *find_get_page_flags(struct address_space *mapping,
     unsigned long offset, int fgp_flags)
{
 return pagecache_get_page(mapping, offset, fgp_flags, 0);
}
# 292 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *find_lock_page(struct address_space *mapping,
     unsigned long offset)
{
 return pagecache_get_page(mapping, offset, 0x00000002, 0);
}
# 317 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *find_or_create_page(struct address_space *mapping,
     unsigned long offset, gfp_t gfp_mask)
{
 return pagecache_get_page(mapping, offset,
     0x00000002|0x00000001|0x00000004,
     gfp_mask);
}
# 338 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct page *grab_cache_page_nowait(struct address_space *mapping,
    unsigned long index)
{
 return pagecache_get_page(mapping, index,
   0x00000002|0x00000004|0x00000010|0x00000020,
   mapping_gfp_mask(mapping));
}

struct page *find_get_entry(struct address_space *mapping, unsigned long offset);
struct page *find_lock_entry(struct address_space *mapping, unsigned long offset);
unsigned find_get_entries(struct address_space *mapping, unsigned long start,
     unsigned int nr_entries, struct page **entries,
     unsigned long *indices);
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)) __attribute__((no_instrument_function)) 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 * read_cache_page(struct address_space *mapping,
    unsigned long index, filler_t *filler, void *data);
extern struct page * read_cache_page_gfp(struct address_space *mapping,
    unsigned long index, gfp_t gfp_mask);
extern int read_cache_pages(struct address_space *mapping,
  struct list_head *pages, filler_t *filler, void *data);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) unsigned long page_to_pgoff(struct page *page)
{
 if (__builtin_expect(!!(PageHeadHuge(page)), 0))
  return page->index << compound_order(page);
 else
  return page->index << (12 - 12);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) loff_t page_offset(struct page *page)
{
 return ((loff_t)page->index) << 12;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) loff_t page_file_offset(struct page *page)
{
 return ((loff_t)page_file_index(page)) << 12;
}

extern unsigned long linear_hugepage_index(struct vm_area_struct *vma,
         unsigned long address);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long linear_page_index(struct vm_area_struct *vma,
     unsigned long address)
{
 unsigned long pgoff;
 if (__builtin_expect(!!(is_vm_hugetlb_page(vma)), 0))
  return linear_hugepage_index(vma, address);
 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 int __lock_page_or_retry(struct page *page, struct mm_struct *mm,
    unsigned int flags);
extern void unlock_page(struct page *page);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int trylock_page(struct page *page)
{
 page = compound_head(page);
 return (__builtin_expect(!!(!_test_and_set_bit(PG_locked,&page->flags)), 1));
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void lock_page(struct page *page)
{
 do { do { } while (0); } while (0);
 if (!trylock_page(page))
  __lock_page(page);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int lock_page_killable(struct page *page)
{
 do { do { } while (0); } while (0);
 if (!trylock_page(page))
  return __lock_page_killable(page);
 return 0;
}
# 465 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int lock_page_or_retry(struct page *page, struct mm_struct *mm,
         unsigned int flags)
{
 do { do { } while (0); } while (0);
 return trylock_page(page) || __lock_page_or_retry(page, mm, flags);
}





extern void wait_on_page_bit(struct page *page, int bit_nr);

extern int wait_on_page_bit_killable(struct page *page, int bit_nr);
extern int wait_on_page_bit_killable_timeout(struct page *page,
          int bit_nr, unsigned long timeout);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int wait_on_page_locked_killable(struct page *page)
{
 if (!PageLocked(page))
  return 0;
 return wait_on_page_bit_killable(compound_head(page), PG_locked);
}

extern wait_queue_head_t *page_waitqueue(struct page *page);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void wake_up_page(struct page *page, int bit)
{
 __wake_up_bit(page_waitqueue(page), &page->flags, bit);
}
# 502 "include/linux/pagemap.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void wait_on_page_locked(struct page *page)
{
 if (PageLocked(page))
  wait_on_page_bit(compound_head(page), PG_locked);
}




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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);
void wait_for_stable_page(struct page *page);

void page_endio(struct page *page, int rw, int err);




extern void add_page_wait_queue(struct page *page, wait_queue_t *waiter);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int fault_in_pages_writeable(char *uaddr, int size)
{
 int ret;

 if (__builtin_expect(!!(size == 0), 0))
  return 0;





 ret = ({ long __pu_err = 0; do { unsigned long __pu_addr = (unsigned long)((uaddr)); __typeof__(*((uaddr))) __pu_val = ((0)); (void)0; might_fault(); switch (sizeof(*((uaddr)))) { case 1: __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __temp = ( unsigned long)(__pu_val); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp), "r" (__pu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp >> 8), "r" (__pu_addr + 1), "i" (-14) : "cc"); }); break; case 4: __asm__ __volatile__( "1:	" "str" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 8: __asm__ __volatile__( "1:	" "str" "	" "%Q2" ", [%1], #4\n" "2:	" "str" "	" "%R2" ", [%1]\n" "3:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "4:	mov	%0, %3\n" "	b	3b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 4b\n" "	.long	2b, 4b\n" "	.popsection" : "+r" (__pu_err), "+r" (__pu_addr) : "r" (__pu_val), "i" (-14) : "cc"); break; default: __put_user_bad(); } } while (0); __pu_err; });
 if (ret == 0) {
  char *end = uaddr + size - 1;





  if (((unsigned long)uaddr & (~((1 << 12) - 1))) !=
    ((unsigned long)end & (~((1 << 12) - 1))))
   ret = ({ long __pu_err = 0; do { unsigned long __pu_addr = (unsigned long)((end)); __typeof__(*((end))) __pu_val = ((0)); (void)0; might_fault(); switch (sizeof(*((end)))) { case 1: __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __temp = ( unsigned long)(__pu_val); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp), "r" (__pu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp >> 8), "r" (__pu_addr + 1), "i" (-14) : "cc"); }); break; case 4: __asm__ __volatile__( "1:	" "str" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 8: __asm__ __volatile__( "1:	" "str" "	" "%Q2" ", [%1], #4\n" "2:	" "str" "	" "%R2" ", [%1]\n" "3:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "4:	mov	%0, %3\n" "	b	3b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 4b\n" "	.long	2b, 4b\n" "	.popsection" : "+r" (__pu_err), "+r" (__pu_addr) : "r" (__pu_val), "i" (-14) : "cc"); break; default: __put_user_bad(); } } while (0); __pu_err; });
 }
 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int fault_in_pages_readable(const char *uaddr, int size)
{
 volatile char c;
 int ret;

 if (__builtin_expect(!!(size == 0), 0))
  return 0;

 ret = ({ long __gu_err = 0; do { unsigned long __gu_addr = (unsigned long)((uaddr)); unsigned long __gu_val; (void)0; might_fault(); switch (sizeof(*((uaddr)))) { case 1: __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __b1, __b2; __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b1) : "r" (__gu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b2) : "r" (__gu_addr + 1), "i" (-14) : "cc"); (__gu_val) = __b1 | (__b2 << 8); }); break; case 4: __asm__ __volatile__( "1:	" "ldr" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; default: (__gu_val) = __get_user_bad(); } ((c)) = (__typeof__(*((uaddr))))__gu_val; } while (0); __gu_err; });
 if (ret == 0) {
  const char *end = uaddr + size - 1;

  if (((unsigned long)uaddr & (~((1 << 12) - 1))) !=
    ((unsigned long)end & (~((1 << 12) - 1)))) {
   ret = ({ long __gu_err = 0; do { unsigned long __gu_addr = (unsigned long)((end)); unsigned long __gu_val; (void)0; might_fault(); switch (sizeof(*((end)))) { case 1: __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __b1, __b2; __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b1) : "r" (__gu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b2) : "r" (__gu_addr + 1), "i" (-14) : "cc"); (__gu_val) = __b1 | (__b2 << 8); }); break; case 4: __asm__ __volatile__( "1:	" "ldr" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; default: (__gu_val) = __get_user_bad(); } ((c)) = (__typeof__(*((end))))__gu_val; } while (0); __gu_err; });
   (void)c;
  }
 }
 return ret;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int fault_in_multipages_writeable(char *uaddr, int size)
{
 int ret = 0;
 char *end = uaddr + size - 1;

 if (__builtin_expect(!!(size == 0), 0))
  return ret;





 while (uaddr <= end) {
  ret = ({ long __pu_err = 0; do { unsigned long __pu_addr = (unsigned long)((uaddr)); __typeof__(*((uaddr))) __pu_val = ((0)); (void)0; might_fault(); switch (sizeof(*((uaddr)))) { case 1: __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __temp = ( unsigned long)(__pu_val); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp), "r" (__pu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp >> 8), "r" (__pu_addr + 1), "i" (-14) : "cc"); }); break; case 4: __asm__ __volatile__( "1:	" "str" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 8: __asm__ __volatile__( "1:	" "str" "	" "%Q2" ", [%1], #4\n" "2:	" "str" "	" "%R2" ", [%1]\n" "3:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "4:	mov	%0, %3\n" "	b	3b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 4b\n" "	.long	2b, 4b\n" "	.popsection" : "+r" (__pu_err), "+r" (__pu_addr) : "r" (__pu_val), "i" (-14) : "cc"); break; default: __put_user_bad(); } } while (0); __pu_err; });
  if (ret != 0)
   return ret;
  uaddr += ((1UL) << 12);
 }


 if (((unsigned long)uaddr & (~((1 << 12) - 1))) ==
   ((unsigned long)end & (~((1 << 12) - 1))))
  ret = ({ long __pu_err = 0; do { unsigned long __pu_addr = (unsigned long)((end)); __typeof__(*((end))) __pu_val = ((0)); (void)0; might_fault(); switch (sizeof(*((end)))) { case 1: __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __temp = ( unsigned long)(__pu_val); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp), "r" (__pu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "strb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__temp >> 8), "r" (__pu_addr + 1), "i" (-14) : "cc"); }); break; case 4: __asm__ __volatile__( "1:	" "str" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__pu_err) : "r" (__pu_val), "r" (__pu_addr), "i" (-14) : "cc"); break; case 8: __asm__ __volatile__( "1:	" "str" "	" "%Q2" ", [%1], #4\n" "2:	" "str" "	" "%R2" ", [%1]\n" "3:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "4:	mov	%0, %3\n" "	b	3b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 4b\n" "	.long	2b, 4b\n" "	.popsection" : "+r" (__pu_err), "+r" (__pu_addr) : "r" (__pu_val), "i" (-14) : "cc"); break; default: __put_user_bad(); } } while (0); __pu_err; });

 return ret;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int fault_in_multipages_readable(const char *uaddr,
            int size)
{
 volatile char c;
 int ret = 0;
 const char *end = uaddr + size - 1;

 if (__builtin_expect(!!(size == 0), 0))
  return ret;

 while (uaddr <= end) {
  ret = ({ long __gu_err = 0; do { unsigned long __gu_addr = (unsigned long)((uaddr)); unsigned long __gu_val; (void)0; might_fault(); switch (sizeof(*((uaddr)))) { case 1: __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __b1, __b2; __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b1) : "r" (__gu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b2) : "r" (__gu_addr + 1), "i" (-14) : "cc"); (__gu_val) = __b1 | (__b2 << 8); }); break; case 4: __asm__ __volatile__( "1:	" "ldr" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; default: (__gu_val) = __get_user_bad(); } ((c)) = (__typeof__(*((uaddr))))__gu_val; } while (0); __gu_err; });
  if (ret != 0)
   return ret;
  uaddr += ((1UL) << 12);
 }


 if (((unsigned long)uaddr & (~((1 << 12) - 1))) ==
   ((unsigned long)end & (~((1 << 12) - 1)))) {
  ret = ({ long __gu_err = 0; do { unsigned long __gu_addr = (unsigned long)((end)); unsigned long __gu_val; (void)0; might_fault(); switch (sizeof(*((end)))) { case 1: __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; case 2: ({ unsigned long __b1, __b2; __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b1) : "r" (__gu_addr), "i" (-14) : "cc"); __asm__ __volatile__( "1:	" "ldrb" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__b2) : "r" (__gu_addr + 1), "i" (-14) : "cc"); (__gu_val) = __b1 | (__b2 << 8); }); break; case 4: __asm__ __volatile__( "1:	" "ldr" "	%1,[%2],#0\n" "2:\n" "	.pushsection .fixup,\"ax\"\n" "	.align	2\n" "3:	mov	%0, %3\n" "	mov	%1, #0\n" "	b	2b\n" "	.popsection\n" "	.pushsection __ex_table,\"a\"\n" "	.align	3\n" "	.long	1b, 3b\n" "	.popsection" : "+r" (__gu_err), "=&r" (__gu_val) : "r" (__gu_addr), "i" (-14) : "cc"); break; default: (__gu_val) = __get_user_bad(); } ((c)) = (__typeof__(*((end))))__gu_val; } while (0); __gu_err; });
  (void)c;
 }

 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 delete_from_page_cache(struct page *page);
extern void __delete_from_page_cache(struct page *page, void *shadow);
int replace_page_cache_page(struct page *old, struct page *new, gfp_t gfp_mask);





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int add_to_page_cache(struct page *page,
  struct address_space *mapping, unsigned long offset, gfp_t gfp_mask)
{
 int error;

 __SetPageLocked(page);
 error = add_to_page_cache_locked(page, mapping, offset, gfp_mask);
 if (__builtin_expect(!!(error), 0))
  __ClearPageLocked(page);
 return error;
}
# 15 "include/linux/mempolicy.h" 2
# 1 "include/uapi/linux/mempolicy.h" 1
# 18 "include/uapi/linux/mempolicy.h"
enum {
 MPOL_DEFAULT,
 MPOL_PREFERRED,
 MPOL_BIND,
 MPOL_INTERLEAVE,
 MPOL_LOCAL,
 MPOL_MAX,
};

enum mpol_rebind_step {
 MPOL_REBIND_ONCE,
 MPOL_REBIND_STEP1,
 MPOL_REBIND_STEP2,
 MPOL_REBIND_NSTEP,
};
# 16 "include/linux/mempolicy.h" 2

struct mm_struct;
# 201 "include/linux/mempolicy.h"
struct mempolicy {};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mpol_equal(struct mempolicy *a, struct mempolicy *b)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_put(struct mempolicy *p)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_cond_put(struct mempolicy *pol)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_get(struct mempolicy *pol)
{
}

struct shared_policy {};

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_shared_policy_init(struct shared_policy *sp,
      struct mempolicy *mpol)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_free_shared_policy(struct shared_policy *p)
{
}



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void numa_policy_init(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void numa_default_policy(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_rebind_task(struct task_struct *tsk,
    const nodemask_t *new,
    enum mpol_rebind_step step)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct zonelist *huge_zonelist(struct vm_area_struct *vma,
    unsigned long addr, gfp_t gfp_flags,
    struct mempolicy **mpol, nodemask_t **nodemask)
{
 *mpol = ((void *)0);
 *nodemask = ((void *)0);
 return node_zonelist(0, gfp_flags);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool init_nodemask_of_mempolicy(nodemask_t *m)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
       const nodemask_t *to, int flags)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void check_highest_zone(int k)
{
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mpol_parse_str(char *str, struct mempolicy **mpol)
{
 return 1;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mpol_misplaced(struct page *page, struct vm_area_struct *vma,
     unsigned long address)
{
 return -1;
}
# 6 "include/linux/migrate.h" 2


typedef struct page *new_page_t(struct page *page, unsigned long private,
    int **reason);
typedef void free_page_t(struct page *page, unsigned long private);
# 19 "include/linux/migrate.h"
enum migrate_reason {
 MR_COMPACTION,
 MR_MEMORY_FAILURE,
 MR_MEMORY_HOTPLUG,
 MR_SYSCALL,
 MR_MEMPOLICY_MBIND,
 MR_NUMA_MISPLACED,
 MR_CMA
};



extern void putback_movable_pages(struct list_head *l);
extern int migrate_page(struct address_space *,
   struct page *, struct page *, enum migrate_mode);
extern int migrate_pages(struct list_head *l, new_page_t new, free_page_t free,
  unsigned long private, enum migrate_mode mode, int reason);

extern int migrate_prep(void);
extern int migrate_prep_local(void);
extern void migrate_page_copy(struct page *newpage, struct page *page);
extern int migrate_huge_page_move_mapping(struct address_space *mapping,
      struct page *newpage, struct page *page);
extern int migrate_page_move_mapping(struct address_space *mapping,
  struct page *newpage, struct page *page,
  struct buffer_head *head, enum migrate_mode mode,
  int extra_count);
# 73 "include/linux/migrate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool pmd_trans_migrating(pmd_t pmd)
{
 return false;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int migrate_misplaced_page(struct page *page,
      struct vm_area_struct *vma, int node)
{
 return -11;
}
# 91 "include/linux/migrate.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int migrate_misplaced_transhuge_page(struct mm_struct *mm,
   struct vm_area_struct *vma,
   pmd_t *pmd, pmd_t entry,
   unsigned long address,
   struct page *page, int node)
{
 return -11;
}
# 16 "mm/migrate.c" 2

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







# 1 "include/linux/memcontrol.h" 1
# 22 "include/linux/memcontrol.h"
# 1 "include/linux/cgroup.h" 1
# 16 "include/linux/cgroup.h"
# 1 "./include/uapi/linux/cgroupstats.h" 1
# 19 "./include/uapi/linux/cgroupstats.h"
# 1 "./include/uapi/linux/taskstats.h" 1
# 40 "./include/uapi/linux/taskstats.h"
struct taskstats {





 __u16 version;
 __u32 ac_exitcode;




 __u8 ac_flag;
 __u8 ac_nice;
# 71 "./include/uapi/linux/taskstats.h"
 __u64 cpu_count __attribute__((aligned(8)));
 __u64 cpu_delay_total;






 __u64 blkio_count;
 __u64 blkio_delay_total;


 __u64 swapin_count;
 __u64 swapin_delay_total;







 __u64 cpu_run_real_total;







 __u64 cpu_run_virtual_total;




 char ac_comm[32];
 __u8 ac_sched __attribute__((aligned(8)));

 __u8 ac_pad[3];
 __u32 ac_uid __attribute__((aligned(8)));

 __u32 ac_gid;
 __u32 ac_pid;
 __u32 ac_ppid;
 __u32 ac_btime;
 __u64 ac_etime __attribute__((aligned(8)));

 __u64 ac_utime;
 __u64 ac_stime;
 __u64 ac_minflt;
 __u64 ac_majflt;
# 130 "./include/uapi/linux/taskstats.h"
 __u64 coremem;



 __u64 virtmem;




 __u64 hiwater_rss;
 __u64 hiwater_vm;


 __u64 read_char;
 __u64 write_char;
 __u64 read_syscalls;
 __u64 write_syscalls;




 __u64 read_bytes;
 __u64 write_bytes;
 __u64 cancelled_write_bytes;

 __u64 nvcsw;
 __u64 nivcsw;


 __u64 ac_utimescaled;
 __u64 ac_stimescaled;
 __u64 cpu_scaled_run_real_total;


 __u64 freepages_count;
 __u64 freepages_delay_total;
};
# 175 "./include/uapi/linux/taskstats.h"
enum {
 TASKSTATS_CMD_UNSPEC = 0,
 TASKSTATS_CMD_GET,
 TASKSTATS_CMD_NEW,
 __TASKSTATS_CMD_MAX,
};



enum {
 TASKSTATS_TYPE_UNSPEC = 0,
 TASKSTATS_TYPE_PID,
 TASKSTATS_TYPE_TGID,
 TASKSTATS_TYPE_STATS,
 TASKSTATS_TYPE_AGGR_PID,
 TASKSTATS_TYPE_AGGR_TGID,
 TASKSTATS_TYPE_NULL,
 __TASKSTATS_TYPE_MAX,
};



enum {
 TASKSTATS_CMD_ATTR_UNSPEC = 0,
 TASKSTATS_CMD_ATTR_PID,
 TASKSTATS_CMD_ATTR_TGID,
 TASKSTATS_CMD_ATTR_REGISTER_CPUMASK,
 TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK,
 __TASKSTATS_CMD_ATTR_MAX,
};
# 20 "./include/uapi/linux/cgroupstats.h" 2
# 31 "./include/uapi/linux/cgroupstats.h"
struct cgroupstats {
 __u64 nr_sleeping;
 __u64 nr_running;
 __u64 nr_stopped;
 __u64 nr_uninterruptible;

 __u64 nr_io_wait;
};







enum {
 CGROUPSTATS_CMD_UNSPEC = __TASKSTATS_CMD_MAX,
 CGROUPSTATS_CMD_GET,
 CGROUPSTATS_CMD_NEW,
 __CGROUPSTATS_CMD_MAX,
};



enum {
 CGROUPSTATS_TYPE_UNSPEC = 0,
 CGROUPSTATS_TYPE_CGROUP_STATS,
 __CGROUPSTATS_TYPE_MAX,
};



enum {
 CGROUPSTATS_CMD_ATTR_UNSPEC = 0,
 CGROUPSTATS_CMD_ATTR_FD,
 __CGROUPSTATS_CMD_ATTR_MAX,
};
# 17 "include/linux/cgroup.h" 2

# 1 "include/linux/idr.h" 1
# 30 "include/linux/idr.h"
struct idr_layer {
 int prefix;
 int layer;
 struct idr_layer *ary[1<<8];
 int count;
 union {

  unsigned long bitmap[((((1 << 8)) + (8 * sizeof(long)) - 1) / (8 * sizeof(long)))];
  struct callback_head callback_head;
 };
};

struct idr {
 struct idr_layer *hint;
 struct idr_layer *top;
 int layers;
 int cur;
 spinlock_t lock;
 int id_free_cnt;
 struct idr_layer *id_free;
};
# 79 "include/linux/idr.h"
void *idr_find_slowpath(struct idr *idp, int id);
void idr_preload(gfp_t gfp_mask);
int idr_alloc(struct idr *idp, void *ptr, int start, int end, gfp_t gfp_mask);
int idr_alloc_cyclic(struct idr *idr, void *ptr, int start, int end, gfp_t gfp_mask);
int idr_for_each(struct idr *idp,
   int (*fn)(int id, void *p, void *data), void *data);
void *idr_get_next(struct idr *idp, int *nextid);
void *idr_replace(struct idr *idp, void *ptr, int id);
void idr_remove(struct idr *idp, int id);
void idr_destroy(struct idr *idp);
void idr_init(struct idr *idp);
bool idr_is_empty(struct idr *idp);







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void idr_preload_end(void)
{
 do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(({ preempt_count_sub(1); should_resched(); })), 0)) preempt_schedule(); } while (0);
}
# 115 "include/linux/idr.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void *idr_find(struct idr *idr, int id)
{
 struct idr_layer *hint = ({ typeof(*(idr->hint)) *________p1 = (typeof(*(idr->hint)) *)({ typeof((idr->hint)) _________p1 = ({ union { typeof((idr->hint)) __val; char __c[1]; } __u; __read_once_size(&((idr->hint)), __u.__c, sizeof((idr->hint))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(idr->hint)) *)(________p1)); });

 if (hint && (id & ~((1 << 8)-1)) == hint->prefix)
  return ({ typeof(*(hint->ary[id & ((1 << 8)-1)])) *________p1 = (typeof(*(hint->ary[id & ((1 << 8)-1)])) *)({ typeof((hint->ary[id & ((1 << 8)-1)])) _________p1 = ({ union { typeof((hint->ary[id & ((1 << 8)-1)])) __val; char __c[1]; } __u; __read_once_size(&((hint->ary[id & ((1 << 8)-1)])), __u.__c, sizeof((hint->ary[id & ((1 << 8)-1)]))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(hint->ary[id & ((1 << 8)-1)])) *)(________p1)); });

 return idr_find_slowpath(idr, id);
}
# 149 "include/linux/idr.h"
struct ida_bitmap {
 long nr_busy;
 unsigned long bitmap[(128 / sizeof(long) - 1)];
};

struct ida {
 struct idr idr;
 struct ida_bitmap *free_bitmap;
};




int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
int ida_get_new_above(struct ida *ida, int starting_id, int *p_id);
void ida_remove(struct ida *ida, int id);
void ida_destroy(struct ida *ida);
void ida_init(struct ida *ida);

int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
     gfp_t gfp_mask);
void ida_simple_remove(struct ida *ida, unsigned int id);
# 179 "include/linux/idr.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int ida_get_new(struct ida *ida, int *p_id)
{
 return ida_get_new_above(ida, 0, p_id);
}

void __attribute__ ((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) idr_init_cache(void);
# 19 "include/linux/cgroup.h" 2


# 1 "include/linux/percpu-refcount.h" 1
# 54 "include/linux/percpu-refcount.h"
struct percpu_ref;
typedef void (percpu_ref_func_t)(struct percpu_ref *);


enum {
 __PERCPU_REF_ATOMIC = 1LU << 0,
 __PERCPU_REF_DEAD = 1LU << 1,
 __PERCPU_REF_ATOMIC_DEAD = __PERCPU_REF_ATOMIC | __PERCPU_REF_DEAD,

 __PERCPU_REF_FLAG_BITS = 2,
};


enum {






 PERCPU_REF_INIT_ATOMIC = 1 << 0,





 PERCPU_REF_INIT_DEAD = 1 << 1,
};

struct percpu_ref {
 atomic_long_t count;




 unsigned long percpu_count_ptr;
 percpu_ref_func_t *release;
 percpu_ref_func_t *confirm_switch;
 bool force_atomic:1;
 struct callback_head rcu;
};

int __attribute__((warn_unused_result)) percpu_ref_init(struct percpu_ref *ref,
     percpu_ref_func_t *release, unsigned int flags,
     gfp_t gfp);
void percpu_ref_exit(struct percpu_ref *ref);
void percpu_ref_switch_to_atomic(struct percpu_ref *ref,
     percpu_ref_func_t *confirm_switch);
void percpu_ref_switch_to_percpu(struct percpu_ref *ref);
void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
     percpu_ref_func_t *confirm_kill);
void percpu_ref_reinit(struct percpu_ref *ref);
# 117 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_ref_kill(struct percpu_ref *ref)
{
 return percpu_ref_kill_and_confirm(ref, ((void *)0));
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool __ref_is_percpu(struct percpu_ref *ref,
       unsigned long **percpu_countp)
{
 unsigned long percpu_ptr;
# 146 "include/linux/percpu-refcount.h"
 percpu_ptr = ({ typeof(ref->percpu_count_ptr) _________p1 = ({ union { typeof(ref->percpu_count_ptr) __val; char __c[1]; } __u; __read_once_size(&(ref->percpu_count_ptr), __u.__c, sizeof(ref->percpu_count_ptr)); __u.__val; }); do { } while(0); (_________p1); });







 if (__builtin_expect(!!(percpu_ptr & __PERCPU_REF_ATOMIC_DEAD), 0))
  return false;

 *percpu_countp = (unsigned long *)percpu_ptr;
 return true;
}
# 170 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_ref_get_many(struct percpu_ref *ref, unsigned long nr)
{
 unsigned long *percpu_count;

 rcu_read_lock_sched();

 if (__ref_is_percpu(ref, &percpu_count))
  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += nr; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 2: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += nr; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 4: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += nr; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 8: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += nr; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
 else
  atomic_long_add(nr, &ref->count);

 rcu_read_unlock_sched();
}
# 192 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_ref_get(struct percpu_ref *ref)
{
 percpu_ref_get_many(ref, 1);
}
# 206 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool percpu_ref_tryget(struct percpu_ref *ref)
{
 unsigned long *percpu_count;
 int ret;

 rcu_read_lock_sched();

 if (__ref_is_percpu(ref, &percpu_count)) {
  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 2: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 4: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 8: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
  ret = true;
 } else {
  ret = atomic_add_unless(((atomic_t *)(&ref->count)), 1, 0);
 }

 rcu_read_unlock_sched();

 return ret;
}
# 240 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool percpu_ref_tryget_live(struct percpu_ref *ref)
{
 unsigned long *percpu_count;
 int ret = false;

 rcu_read_lock_sched();

 if (__ref_is_percpu(ref, &percpu_count)) {
  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 2: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 4: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 8: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += 1; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
  ret = true;
 } else if (!(ref->percpu_count_ptr & __PERCPU_REF_DEAD)) {
  ret = atomic_add_unless(((atomic_t *)(&ref->count)), 1, 0);
 }

 rcu_read_unlock_sched();

 return ret;
}
# 269 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_ref_put_many(struct percpu_ref *ref, unsigned long nr)
{
 unsigned long *percpu_count;

 rcu_read_lock_sched();

 if (__ref_is_percpu(ref, &percpu_count))
  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(*percpu_count))(nr); do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 2: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(*percpu_count))(nr); do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 4: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(*percpu_count))(nr); do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; case 8: do { unsigned long __flags; do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); __flags = arch_local_irq_save(); } while (0); *({ do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))); (typeof((typeof(*(&(*percpu_count))) *)(&(*percpu_count)))) (__ptr + ((__my_cpu_offset()))); }); }) += -(typeof(*percpu_count))(nr); do { ({ unsigned long __dummy; typeof(__flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(__flags); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
 else if (__builtin_expect(!!(atomic_long_sub_and_test(nr, &ref->count)), 0))
  ref->release(ref);

 rcu_read_unlock_sched();
}
# 292 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void percpu_ref_put(struct percpu_ref *ref)
{
 percpu_ref_put_many(ref, 1);
}
# 306 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool percpu_ref_is_dying(struct percpu_ref *ref)
{
 return ref->percpu_count_ptr & __PERCPU_REF_DEAD;
}
# 319 "include/linux/percpu-refcount.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool percpu_ref_is_zero(struct percpu_ref *ref)
{
 unsigned long *percpu_count;

 if (__ref_is_percpu(ref, &percpu_count))
  return false;
 return !atomic_long_read(&ref->count);
}
# 22 "include/linux/cgroup.h" 2
# 1 "include/linux/seq_file.h" 1
# 11 "include/linux/seq_file.h"
struct seq_operations;
struct file;
struct path;
struct inode;
struct dentry;
struct user_namespace;

struct seq_file {
 char *buf;
 size_t size;
 size_t from;
 size_t count;
 size_t pad_until;
 loff_t index;
 loff_t read_pos;
 u64 version;
 struct mutex lock;
 const struct seq_operations *op;
 int poll_event;



 void *private;
};

struct seq_operations {
 void * (*start) (struct seq_file *m, loff_t *pos);
 void (*stop) (struct seq_file *m, void *v);
 void * (*next) (struct seq_file *m, void *v, loff_t *pos);
 int (*show) (struct seq_file *m, void *v);
};
# 55 "include/linux/seq_file.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool seq_has_overflowed(struct seq_file *m)
{
 return m->count == m->size;
}
# 68 "include/linux/seq_file.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) size_t seq_get_buf(struct seq_file *m, char **bufp)
{
 do { if (__builtin_expect(!!(m->count > m->size), 0)) do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/seq_file.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "70" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0); } while (0);
 if (m->count < m->size)
  *bufp = m->buf + m->count;
 else
  *bufp = ((void *)0);

 return m->size - m->count;
}
# 88 "include/linux/seq_file.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void seq_commit(struct seq_file *m, int num)
{
 if (num < 0) {
  m->count = m->size;
 } else {
  do { if (__builtin_expect(!!(m->count + num > m->size), 0)) do { asm volatile("1:\t" ".long " "((0xe7f001f2) & 0xFFFFFFFF)" "\n\t" "\n" ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" "2:\t.asciz " "\"include/linux/seq_file.h\"" "\n" ".popsection\n" ".pushsection __bug_table,\"a\"\n" "3:\t.word 1b, 2b\n" "\t.hword " "93" ", 0\n" ".popsection"); __builtin_unreachable(); } while (0); } while (0);
  m->count += num;
 }
}
# 106 "include/linux/seq_file.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void seq_setwidth(struct seq_file *m, size_t size)
{
 m->pad_until = m->count + size;
}
void seq_pad(struct seq_file *m, char c);

char *mangle_path(char *s, const char *p, const char *esc);
int seq_open(struct file *, const struct seq_operations *);
ssize_t seq_read(struct file *, char *, size_t, loff_t *);
loff_t seq_lseek(struct file *, loff_t, int);
int seq_release(struct inode *, struct file *);
int seq_escape(struct seq_file *, const char *, const char *);
int seq_putc(struct seq_file *m, char c);
int seq_puts(struct seq_file *m, const char *s);
int seq_write(struct seq_file *seq, const void *data, size_t len);

__attribute__((format(printf, 2, 3))) int seq_printf(struct seq_file *, const char *, ...);
__attribute__((format(printf, 2, 0))) int seq_vprintf(struct seq_file *, const char *, va_list args);

int seq_path(struct seq_file *, const struct path *, const char *);
int seq_dentry(struct seq_file *, struct dentry *, const char *);
int seq_path_root(struct seq_file *m, const struct path *path,
    const struct path *root, const char *esc);

int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
int single_open_size(struct file *, int (*)(struct seq_file *, void *), void *, size_t);
int single_release(struct inode *, struct file *);
void *__seq_open_private(struct file *, const struct seq_operations *, int);
int seq_open_private(struct file *, const struct seq_operations *, int);
int seq_release_private(struct inode *, struct file *);
int seq_put_decimal_ull(struct seq_file *m, char delimiter,
   unsigned long long num);
int seq_put_decimal_ll(struct seq_file *m, char delimiter,
   long long num);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct user_namespace *seq_user_ns(struct seq_file *seq)
{



 extern struct user_namespace init_user_ns;
 return &init_user_ns;

}






extern struct list_head *seq_list_start(struct list_head *head,
  loff_t pos);
extern struct list_head *seq_list_start_head(struct list_head *head,
  loff_t pos);
extern struct list_head *seq_list_next(void *v, struct list_head *head,
  loff_t *ppos);





extern struct hlist_node *seq_hlist_start(struct hlist_head *head,
       loff_t pos);
extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head,
            loff_t pos);
extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
      loff_t *ppos);

extern struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
           loff_t pos);
extern struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
         loff_t pos);
extern struct hlist_node *seq_hlist_next_rcu(void *v,
         struct hlist_head *head,
         loff_t *ppos);


extern struct hlist_node *seq_hlist_start_percpu(struct hlist_head *head, int *cpu, loff_t pos);

extern struct hlist_node *seq_hlist_next_percpu(void *v, struct hlist_head *head, int *cpu, loff_t *pos);
# 23 "include/linux/cgroup.h" 2
# 1 "include/linux/kernfs.h" 1
# 20 "include/linux/kernfs.h"
struct file;
struct dentry;
struct iattr;
struct seq_file;
struct vm_area_struct;
struct super_block;
struct file_system_type;

struct kernfs_open_node;
struct kernfs_iattrs;

enum kernfs_node_type {
 KERNFS_DIR = 0x0001,
 KERNFS_FILE = 0x0002,
 KERNFS_LINK = 0x0004,
};




enum kernfs_node_flag {
 KERNFS_ACTIVATED = 0x0010,
 KERNFS_NS = 0x0020,
 KERNFS_HAS_SEQ_SHOW = 0x0040,
 KERNFS_HAS_MMAP = 0x0080,
 KERNFS_LOCKDEP = 0x0100,
 KERNFS_SUICIDAL = 0x0400,
 KERNFS_SUICIDED = 0x0800,
};


enum kernfs_root_flag {






 KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
# 69 "include/linux/kernfs.h"
 KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
};


struct kernfs_elem_dir {
 unsigned long subdirs;

 struct rb_root children;





 struct kernfs_root *root;
};

struct kernfs_elem_symlink {
 struct kernfs_node *target_kn;
};

struct kernfs_elem_attr {
 const struct kernfs_ops *ops;
 struct kernfs_open_node *open;
 loff_t size;
 struct kernfs_node *notify_next;
};
# 105 "include/linux/kernfs.h"
struct kernfs_node {
 atomic_t count;
 atomic_t active;
# 117 "include/linux/kernfs.h"
 struct kernfs_node *parent;
 const char *name;

 struct rb_node rb;

 const void *ns;
 unsigned int hash;
 union {
  struct kernfs_elem_dir dir;
  struct kernfs_elem_symlink symlink;
  struct kernfs_elem_attr attr;
 };

 void *priv;

 unsigned short flags;
 umode_t mode;
 unsigned int ino;
 struct kernfs_iattrs *iattr;
};
# 145 "include/linux/kernfs.h"
struct kernfs_syscall_ops {
 int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
 int (*show_options)(struct seq_file *sf, struct kernfs_root *root);

 int (*mkdir)(struct kernfs_node *parent, const char *name,
       umode_t mode);
 int (*rmdir)(struct kernfs_node *kn);
 int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent,
        const char *new_name);
};

struct kernfs_root {

 struct kernfs_node *kn;
 unsigned int flags;


 struct ida ino_ida;
 struct kernfs_syscall_ops *syscall_ops;


 struct list_head supers;

 wait_queue_head_t deactivate_waitq;
};

struct kernfs_open_file {

 struct kernfs_node *kn;
 struct file *file;
 void *priv;


 struct mutex mutex;
 int event;
 struct list_head list;
 char *prealloc_buf;

 size_t atomic_write_len;
 bool mmapped;
 const struct vm_operations_struct *vm_ops;
};

struct kernfs_ops {
# 200 "include/linux/kernfs.h"
 int (*seq_show)(struct seq_file *sf, void *v);

 void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
 void (*seq_stop)(struct seq_file *sf, void *v);

 ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
   loff_t off);
# 216 "include/linux/kernfs.h"
 size_t atomic_write_len;






 bool prealloc;
 ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
    loff_t off);

 int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);




};



static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
{
 return kn->flags & 0x000f;
}
# 249 "include/linux/kernfs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kernfs_enable_ns(struct kernfs_node *kn)
{
 ({ static bool __attribute__ ((__section__(".data.unlikely"))) __warned; int __ret_warn_once = !!(kernfs_type(kn) != KERNFS_DIR); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/kernfs.h", 251); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
 ({ static bool __attribute__ ((__section__(".data.unlikely"))) __warned; int __ret_warn_once = !!(!((&kn->dir.children)->rb_node == ((void *)0))); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/kernfs.h", 252); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
 kn->flags |= KERNFS_NS;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool kernfs_ns_enabled(struct kernfs_node *kn)
{
 return kn->flags & KERNFS_NS;
}

int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
char * __attribute__((warn_unused_result)) kernfs_path(struct kernfs_node *kn, char *buf,
    size_t buflen);
void pr_cont_kernfs_name(struct kernfs_node *kn);
void pr_cont_kernfs_path(struct kernfs_node *kn);
struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
        const char *name, const void *ns);
void kernfs_get(struct kernfs_node *kn);
void kernfs_put(struct kernfs_node *kn);

struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);

struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
           unsigned int flags, void *priv);
void kernfs_destroy_root(struct kernfs_root *root);

struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
      const char *name, umode_t mode,
      void *priv, const void *ns);
struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
      const char *name,
      umode_t mode, loff_t size,
      const struct kernfs_ops *ops,
      void *priv, const void *ns,
      struct lock_class_key *key);
struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
           const char *name,
           struct kernfs_node *target);
void kernfs_activate(struct kernfs_node *kn);
void kernfs_remove(struct kernfs_node *kn);
void kernfs_break_active_protection(struct kernfs_node *kn);
void kernfs_unbreak_active_protection(struct kernfs_node *kn);
bool kernfs_remove_self(struct kernfs_node *kn);
int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
        const void *ns);
int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
       const char *new_name, const void *new_ns);
int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
void kernfs_notify(struct kernfs_node *kn);

const void *kernfs_super_ns(struct super_block *sb);
struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
          struct kernfs_root *root, unsigned long magic,
          bool *new_sb_created, const void *ns);
void kernfs_kill_sb(struct super_block *sb);
struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns);

void kernfs_init(void);
# 415 "include/linux/kernfs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kernfs_node *
kernfs_find_and_get(struct kernfs_node *kn, const char *name)
{
 return kernfs_find_and_get_ns(kn, name, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kernfs_node *
kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
    void *priv)
{
 return kernfs_create_dir_ns(parent, name, mode, priv, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kernfs_node *
kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
        umode_t mode, loff_t size, const struct kernfs_ops *ops,
        void *priv, const void *ns)
{
 struct lock_class_key *key = ((void *)0);




 return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
        key);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kernfs_node *
kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
     loff_t size, const struct kernfs_ops *ops, void *priv)
{
 return kernfs_create_file_ns(parent, name, mode, size, ops, priv, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kernfs_remove_by_name(struct kernfs_node *parent,
     const char *name)
{
 return kernfs_remove_by_name_ns(parent, name, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kernfs_rename(struct kernfs_node *kn,
    struct kernfs_node *new_parent,
    const char *new_name)
{
 return kernfs_rename_ns(kn, new_parent, new_name, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct dentry *
kernfs_mount(struct file_system_type *fs_type, int flags,
  struct kernfs_root *root, unsigned long magic,
  bool *new_sb_created)
{
 return kernfs_mount_ns(fs_type, flags, root,
    magic, new_sb_created, ((void *)0));
}
# 24 "include/linux/cgroup.h" 2




struct cgroup_root;
struct cgroup_subsys;
struct cgroup;

extern int cgroup_init_early(void);
extern int cgroup_init(void);
extern void cgroup_fork(struct task_struct *p);
extern void cgroup_post_fork(struct task_struct *p);
extern void cgroup_exit(struct task_struct *p);
extern int cgroupstats_build(struct cgroupstats *stats,
    struct dentry *dentry);

extern int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
       struct pid *pid, struct task_struct *tsk);



enum cgroup_subsys_id {
# 1 "include/linux/cgroup_subsys.h" 1
# 47 "include/linux/cgroup.h" 2
 CGROUP_SUBSYS_COUNT,
};
# 58 "include/linux/cgroup.h"
struct cgroup_subsys_state {

 struct cgroup *cgroup;


 struct cgroup_subsys *ss;


 struct percpu_ref refcnt;


 struct cgroup_subsys_state *parent;


 struct list_head sibling;
 struct list_head children;





 int id;

 unsigned int flags;







 u64 serial_nr;


 struct callback_head callback_head;
 struct work_struct destroy_work;
};


enum {
 CSS_NO_REF = (1 << 0),
 CSS_ONLINE = (1 << 1),
 CSS_RELEASED = (1 << 2),
};







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void css_get(struct cgroup_subsys_state *css)
{
 if (!(css->flags & CSS_NO_REF))
  percpu_ref_get(&css->refcnt);
}
# 122 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void css_get_many(struct cgroup_subsys_state *css, unsigned int n)
{
 if (!(css->flags & CSS_NO_REF))
  percpu_ref_get_many(&css->refcnt, n);
}
# 139 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool css_tryget(struct cgroup_subsys_state *css)
{
 if (!(css->flags & CSS_NO_REF))
  return percpu_ref_tryget(&css->refcnt);
 return true;
}
# 156 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool css_tryget_online(struct cgroup_subsys_state *css)
{
 if (!(css->flags & CSS_NO_REF))
  return percpu_ref_tryget_live(&css->refcnt);
 return true;
}







static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void css_put(struct cgroup_subsys_state *css)
{
 if (!(css->flags & CSS_NO_REF))
  percpu_ref_put(&css->refcnt);
}
# 182 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
{
 if (!(css->flags & CSS_NO_REF))
  percpu_ref_put_many(&css->refcnt, n);
}


enum {

 CGRP_NOTIFY_ON_RELEASE,





 CGRP_CPUSET_CLONE_CHILDREN,
};

struct cgroup {

 struct cgroup_subsys_state self;

 unsigned long flags;
# 214 "include/linux/cgroup.h"
 int id;







 int populated_cnt;

 struct kernfs_node *kn;
 struct kernfs_node *populated_kn;
# 235 "include/linux/cgroup.h"
 unsigned int subtree_control;
 unsigned int child_subsys_mask;


 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];

 struct cgroup_root *root;





 struct list_head cset_links;
# 256 "include/linux/cgroup.h"
 struct list_head e_csets[CGROUP_SUBSYS_COUNT];





 struct list_head pidlists;
 struct mutex pidlist_mutex;


 wait_queue_head_t offline_waitq;


 struct work_struct release_agent_work;
};




enum {
 CGRP_ROOT_SANE_BEHAVIOR = (1 << 0),
 CGRP_ROOT_NOPREFIX = (1 << 1),
 CGRP_ROOT_XATTR = (1 << 2),
};






struct cgroup_root {
 struct kernfs_root *kf_root;


 unsigned int subsys_mask;


 int hierarchy_id;


 struct cgroup cgrp;


 atomic_t nr_cgrps;


 struct list_head root_list;


 unsigned int flags;


 struct idr cgroup_idr;


 char release_agent_path[4096];


 char name[64];
};
# 325 "include/linux/cgroup.h"
struct css_set {


 atomic_t refcount;





 struct hlist_node hlist;
# 343 "include/linux/cgroup.h"
 struct list_head tasks;
 struct list_head mg_tasks;





 struct list_head cgrp_links;


 struct cgroup *dfl_cgrp;






 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];





 struct list_head mg_preload_node;
 struct list_head mg_node;
# 376 "include/linux/cgroup.h"
 struct cgroup *mg_src_cgrp;
 struct css_set *mg_dst_cset;
# 386 "include/linux/cgroup.h"
 struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];


 struct callback_head callback_head;
};
# 401 "include/linux/cgroup.h"
enum {
 CFTYPE_ONLY_ON_ROOT = (1 << 0),
 CFTYPE_NOT_ON_ROOT = (1 << 1),
 CFTYPE_NO_PREFIX = (1 << 3),


 __CFTYPE_ONLY_ON_DFL = (1 << 16),
 __CFTYPE_NOT_ON_DFL = (1 << 17),
};



struct cftype {





 char name[64];
 int private;




 umode_t mode;





 size_t max_write_len;


 unsigned int flags;





 struct cgroup_subsys *ss;
 struct list_head node;
 struct kernfs_ops *kf_ops;





 u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);



 s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);


 int (*seq_show)(struct seq_file *sf, void *v);


 void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
 void (*seq_stop)(struct seq_file *sf, void *v);






 int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
    u64 val);



 int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
    s64 val);







 ssize_t (*write)(struct kernfs_open_file *of,
    char *buf, size_t nbytes, loff_t off);




};

extern struct cgroup_root cgrp_dfl_root;
extern struct css_set init_css_set;
# 545 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cgroup_on_dfl(const struct cgroup *cgrp)
{
 return cgrp->root == &cgrp_dfl_root;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool cgroup_has_tasks(struct cgroup *cgrp)
{
 return !list_empty(&cgrp->cset_links);
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) ino_t cgroup_ino(struct cgroup *cgrp)
{
 return cgrp->kn->ino;
}


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cftype *of_cft(struct kernfs_open_file *of)
{
 return of->kn->priv;
}

struct cgroup_subsys_state *of_css(struct kernfs_open_file *of);


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cftype *seq_cft(struct seq_file *seq)
{
 return of_cft(seq->private);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cgroup_subsys_state *seq_css(struct seq_file *seq)
{
 return of_css(seq->private);
}






static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
{
 return kernfs_name(cgrp->kn, buf, buflen);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) char * __attribute__((warn_unused_result)) cgroup_path(struct cgroup *cgrp, char *buf,
           size_t buflen)
{
 return kernfs_path(cgrp->kn, buf, buflen);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pr_cont_cgroup_name(struct cgroup *cgrp)
{
 pr_cont_kernfs_name(cgrp->kn);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void pr_cont_cgroup_path(struct cgroup *cgrp)
{
 pr_cont_kernfs_path(cgrp->kn);
}

char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);

int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
int cgroup_rm_cftypes(struct cftype *cfts);

bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);





struct cgroup_taskset;
struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
# 637 "include/linux/cgroup.h"
struct cgroup_subsys {
 struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
 int (*css_online)(struct cgroup_subsys_state *css);
 void (*css_offline)(struct cgroup_subsys_state *css);
 void (*css_released)(struct cgroup_subsys_state *css);
 void (*css_free)(struct cgroup_subsys_state *css);
 void (*css_reset)(struct cgroup_subsys_state *css);
 void (*css_e_css_changed)(struct cgroup_subsys_state *css);

 int (*can_attach)(struct cgroup_subsys_state *css,
     struct cgroup_taskset *tset);
 void (*cancel_attach)(struct cgroup_subsys_state *css,
         struct cgroup_taskset *tset);
 void (*attach)(struct cgroup_subsys_state *css,
         struct cgroup_taskset *tset);
 void (*fork)(struct task_struct *task);
 void (*exit)(struct cgroup_subsys_state *css,
       struct cgroup_subsys_state *old_css,
       struct task_struct *task);
 void (*bind)(struct cgroup_subsys_state *root_css);

 int disabled;
 int early_init;
# 673 "include/linux/cgroup.h"
 bool broken_hierarchy;
 bool warned_broken_hierarchy;


 int id;

 const char *name;


 struct cgroup_root *root;


 struct idr css_idr;





 struct list_head cfts;





 struct cftype *dfl_cftypes;
 struct cftype *legacy_cftypes;
# 707 "include/linux/cgroup.h"
 unsigned int depends_on;
};


# 1 "include/linux/cgroup_subsys.h" 1
# 712 "include/linux/cgroup.h" 2
# 758 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct css_set *task_css_set(struct task_struct *task)
{
 return ({ typeof(*((task)->cgroups)) *________p1 = (typeof(*((task)->cgroups)) *)({ typeof(((task)->cgroups)) _________p1 = ({ union { typeof(((task)->cgroups)) __val; char __c[1]; } __u; __read_once_size(&(((task)->cgroups)), __u.__c, sizeof(((task)->cgroups))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*((task)->cgroups)) *)(________p1)); });
}
# 770 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cgroup_subsys_state *task_css(struct task_struct *task,
         int subsys_id)
{
 return ({ typeof(*(((task))->cgroups)) *________p1 = (typeof(*(((task))->cgroups)) *)({ typeof((((task))->cgroups)) _________p1 = ({ union { typeof((((task))->cgroups)) __val; char __c[1]; } __u; __read_once_size(&((((task))->cgroups)), __u.__c, sizeof((((task))->cgroups))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(((task))->cgroups)) *)(________p1)); })->subsys[(subsys_id)];
}
# 784 "include/linux/cgroup.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool task_css_is_root(struct task_struct *task, int subsys_id)
{
 return ({ typeof(*(((task))->cgroups)) *________p1 = (typeof(*(((task))->cgroups)) *)({ typeof((((task))->cgroups)) _________p1 = ({ union { typeof((((task))->cgroups)) __val; char __c[1]; } __u; __read_once_size(&((((task))->cgroups)), __u.__c, sizeof((((task))->cgroups))); __u.__val; }); do { } while(0); (_________p1); }); do { } while (0); ; ((typeof(*(((task))->cgroups)) *)(________p1)); })->subsys[(subsys_id)] ==
  init_css_set.subsys[subsys_id];
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cgroup *task_cgroup(struct task_struct *task,
      int subsys_id)
{
 return task_css(task, subsys_id)->cgroup;
}

struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
        struct cgroup_subsys_state *parent);

struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
# 823 "include/linux/cgroup.h"
struct cgroup_subsys_state *
css_next_descendant_pre(struct cgroup_subsys_state *pos,
   struct cgroup_subsys_state *css);

struct cgroup_subsys_state *
css_rightmost_descendant(struct cgroup_subsys_state *pos);
# 890 "include/linux/cgroup.h"
struct cgroup_subsys_state *
css_next_descendant_post(struct cgroup_subsys_state *pos,
    struct cgroup_subsys_state *css);
# 917 "include/linux/cgroup.h"
bool css_has_online_children(struct cgroup_subsys_state *css);


struct css_task_iter {
 struct cgroup_subsys *ss;

 struct list_head *cset_pos;
 struct list_head *cset_head;

 struct list_head *task_pos;
 struct list_head *tasks_head;
 struct list_head *mg_tasks_head;
};

void css_task_iter_start(struct cgroup_subsys_state *css,
    struct css_task_iter *it);
struct task_struct *css_task_iter_next(struct css_task_iter *it);
void css_task_iter_end(struct css_task_iter *it);

int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);

struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
          struct cgroup_subsys *ss);
struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
             struct cgroup_subsys *ss);
# 23 "include/linux/memcontrol.h" 2




struct mem_cgroup;
struct page;
struct mm_struct;
struct kmem_cache;





enum mem_cgroup_stat_index {



 MEM_CGROUP_STAT_CACHE,
 MEM_CGROUP_STAT_RSS,
 MEM_CGROUP_STAT_RSS_HUGE,
 MEM_CGROUP_STAT_FILE_MAPPED,
 MEM_CGROUP_STAT_WRITEBACK,
 MEM_CGROUP_STAT_SWAP,
 MEM_CGROUP_STAT_NSTATS,
};

struct mem_cgroup_reclaim_cookie {
 struct zone *zone;
 int priority;
 unsigned int generation;
};

enum mem_cgroup_events_index {
 MEM_CGROUP_EVENTS_PGPGIN,
 MEM_CGROUP_EVENTS_PGPGOUT,
 MEM_CGROUP_EVENTS_PGFAULT,
 MEM_CGROUP_EVENTS_PGMAJFAULT,
 MEM_CGROUP_EVENTS_NSTATS,

 MEMCG_LOW = MEM_CGROUP_EVENTS_NSTATS,
 MEMCG_HIGH,
 MEMCG_MAX,
 MEMCG_OOM,
 MEMCG_NR_EVENTS,
};
# 196 "include/linux/memcontrol.h"
struct mem_cgroup;

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_events(struct mem_cgroup *memcg,
         enum mem_cgroup_events_index idx,
         unsigned int nr)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mem_cgroup_low(struct mem_cgroup *root,
      struct mem_cgroup *memcg)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
     gfp_t gfp_mask,
     struct mem_cgroup **memcgp)
{
 *memcgp = ((void *)0);
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_commit_charge(struct page *page,
         struct mem_cgroup *memcg,
         bool lrucare)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_cancel_charge(struct page *page,
         struct mem_cgroup *memcg)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_uncharge(struct page *page)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_uncharge_list(struct list_head *page_list)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_migrate(struct page *oldpage,
          struct page *newpage,
          bool lrucare)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
          struct mem_cgroup *memcg)
{
 return &zone->lruvec;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct lruvec *mem_cgroup_page_lruvec(struct page *page,
          struct zone *zone)
{
 return &zone->lruvec;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mm_match_cgroup(struct mm_struct *mm,
  struct mem_cgroup *memcg)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool task_in_mem_cgroup(struct task_struct *task,
          const struct mem_cgroup *memcg)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct cgroup_subsys_state
  *mem_cgroup_css(struct mem_cgroup *memcg)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct mem_cgroup *
mem_cgroup_iter(struct mem_cgroup *root,
  struct mem_cgroup *prev,
  struct mem_cgroup_reclaim_cookie *reclaim)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_iter_break(struct mem_cgroup *root,
      struct mem_cgroup *prev)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mem_cgroup_disabled(void)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int
mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
{
 return 1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long
mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
         int increment)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page)
{
 return ((void *)0);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_end_page_stat(struct mem_cgroup *memcg)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_oom_enable(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_oom_disable(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool task_in_memcg_oom(struct task_struct *p)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool mem_cgroup_oom_synchronize(bool wait)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
         enum mem_cgroup_stat_index idx)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
         enum mem_cgroup_stat_index idx)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function))
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
         gfp_t gfp_mask,
         unsigned long *total_scanned)
{
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void mem_cgroup_split_huge_fixup(struct page *head)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function))
void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
{
}


enum {
 UNDER_LIMIT,
 SOFT_LIMIT,
 OVER_LIMIT,
};

struct sock;




static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sock_update_memcg(struct sock *sk)
{
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sock_release_memcg(struct sock *sk)
{
}
# 551 "include/linux/memcontrol.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool memcg_kmem_enabled(void)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool memcg_kmem_is_active(struct mem_cgroup *memcg)
{
 return false;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool
memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
{
 return true;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void memcg_kmem_uncharge_pages(struct page *page, int order)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void
memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int memcg_cache_id(struct mem_cgroup *memcg)
{
 return -1;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void memcg_get_cache_ids(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void memcg_put_cache_ids(void)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kmem_cache *
memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
{
 return cachep;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void memcg_kmem_put_cache(struct kmem_cache *cachep)
{
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
{
 return ((void *)0);
}
# 9 "include/linux/swap.h" 2

# 1 "include/linux/node.h" 1
# 17 "include/linux/node.h"
# 1 "include/linux/device.h" 1
# 16 "include/linux/device.h"
# 1 "include/linux/ioport.h" 1
# 18 "include/linux/ioport.h"
struct resource {
 resource_size_t start;
 resource_size_t end;
 const char *name;
 unsigned long flags;
 struct resource *parent, *sibling, *child;
};
# 138 "include/linux/ioport.h"
extern struct resource ioport_resource;
extern struct resource iomem_resource;

extern struct resource *request_resource_conflict(struct resource *root, struct resource *new);
extern int request_resource(struct resource *root, struct resource *new);
extern int release_resource(struct resource *new);
void release_child_resources(struct resource *new);
extern void reserve_region_with_split(struct resource *root,
        resource_size_t start, resource_size_t end,
        const char *name);
extern struct resource *insert_resource_conflict(struct resource *parent, struct resource *new);
extern int insert_resource(struct resource *parent, struct resource *new);
extern void insert_resource_expand_to_fit(struct resource *root, struct resource *new);
extern void arch_remove_reservations(struct resource *avail);
extern int allocate_resource(struct resource *root, struct resource *new,
        resource_size_t size, resource_size_t min,
        resource_size_t max, resource_size_t align,
        resource_size_t (*alignf)(void *,
             const struct resource *,
             resource_size_t,
             resource_size_t),
        void *alignf_data);
struct resource *lookup_resource(struct resource *root, resource_size_t start);
int adjust_resource(struct resource *res, resource_size_t start,
      resource_size_t size);
resource_size_t resource_alignment(struct resource *res);
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) resource_size_t resource_size(const struct resource *res)
{
 return res->end - res->start + 1;
}
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) unsigned long resource_type(const struct resource *res)
{
 return res->flags & 0x00001f00;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool resource_contains(struct resource *r1, struct resource *r2)
{
 if (resource_type(r1) != resource_type(r2))
  return false;
 if (r1->flags & 0x20000000 || r2->flags & 0x20000000)
  return false;
 return r1->start <= r2->start && r1->end >= r2->end;
}
# 192 "include/linux/ioport.h"
extern struct resource * __request_region(struct resource *,
     resource_size_t start,
     resource_size_t n,
     const char *name, int flags);





extern void __release_region(struct resource *, resource_size_t,
    resource_size_t);






struct device;

extern int devm_request_resource(struct device *dev, struct resource *root,
     struct resource *new);
extern void devm_release_resource(struct device *dev, struct resource *new);






extern struct resource * __devm_request_region(struct device *dev,
    struct resource *parent, resource_size_t start,
    resource_size_t n, const char *name);






extern void __devm_release_region(struct device *dev, struct resource *parent,
      resource_size_t start, resource_size_t n);
extern int iomem_map_sanity_check(resource_size_t addr, unsigned long size);
extern int iomem_is_exclusive(u64 addr);

extern int
walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
  void *arg, int (*func)(unsigned long, unsigned long, void *));
extern int
walk_system_ram_res(u64 start, u64 end, void *arg,
      int (*func)(u64, u64, void *));
extern int
walk_iomem_res(char *name, unsigned long flags, u64 start, u64 end, void *arg,
        int (*func)(u64, u64, void *));


static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) bool resource_overlaps(struct resource *r1, struct resource *r2)
{
       return (r1->start <= r2->end && r1->end >= r2->start);
}
# 17 "include/linux/device.h" 2
# 1 "include/linux/kobject.h" 1
# 21 "include/linux/kobject.h"
# 1 "include/linux/sysfs.h" 1
# 20 "include/linux/sysfs.h"
# 1 "include/linux/kobject_ns.h" 1
# 20 "include/linux/kobject_ns.h"
struct sock;
struct kobject;





enum kobj_ns_type {
 KOBJ_NS_TYPE_NONE = 0,
 KOBJ_NS_TYPE_NET,
 KOBJ_NS_TYPES
};
# 40 "include/linux/kobject_ns.h"
struct kobj_ns_type_operations {
 enum kobj_ns_type type;
 bool (*current_may_mount)(void);
 void *(*grab_current_ns)(void);
 const void *(*netlink_ns)(struct sock *sk);
 const void *(*initial_ns)(void);
 void (*drop_ns)(void *);
};

int kobj_ns_type_register(const struct kobj_ns_type_operations *ops);
int kobj_ns_type_registered(enum kobj_ns_type type);
const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent);
const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj);

bool kobj_ns_current_may_mount(enum kobj_ns_type type);
void *kobj_ns_grab_current(enum kobj_ns_type type);
const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk);
const void *kobj_ns_initial(enum kobj_ns_type type);
void kobj_ns_drop(enum kobj_ns_type type, void *ns);
# 21 "include/linux/sysfs.h" 2



struct kobject;
struct module;
struct bin_attribute;
enum kobj_ns_type;

struct attribute {
 const char *name;
 umode_t mode;





};
# 75 "include/linux/sysfs.h"
struct attribute_group {
 const char *name;
 umode_t (*is_visible)(struct kobject *,
           struct attribute *, int);
 struct attribute **attrs;
 struct bin_attribute **bin_attrs;
};
# 142 "include/linux/sysfs.h"
struct file;
struct vm_area_struct;

struct bin_attribute {
 struct attribute attr;
 size_t size;
 void *private;
 ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *,
   char *, loff_t, size_t);
 ssize_t (*write)(struct file *, struct kobject *, struct bin_attribute *,
    char *, loff_t, size_t);
 int (*mmap)(struct file *, struct kobject *, struct bin_attribute *attr,
      struct vm_area_struct *vma);
};
# 199 "include/linux/sysfs.h"
struct sysfs_ops {
 ssize_t (*show)(struct kobject *, struct attribute *, char *);
 ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
};



int __attribute__((warn_unused_result)) sysfs_create_dir_ns(struct kobject *kobj, const void *ns);
void sysfs_remove_dir(struct kobject *kobj);
int __attribute__((warn_unused_result)) sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
         const void *new_ns);
int __attribute__((warn_unused_result)) sysfs_move_dir_ns(struct kobject *kobj,
       struct kobject *new_parent_kobj,
       const void *new_ns);

int __attribute__((warn_unused_result)) sysfs_create_file_ns(struct kobject *kobj,
          const struct attribute *attr,
          const void *ns);
int __attribute__((warn_unused_result)) sysfs_create_files(struct kobject *kobj,
       const struct attribute **attr);
int __attribute__((warn_unused_result)) sysfs_chmod_file(struct kobject *kobj,
      const struct attribute *attr, umode_t mode);
void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
     const void *ns);
bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr);
void sysfs_remove_files(struct kobject *kobj, const struct attribute **attr);

int __attribute__((warn_unused_result)) sysfs_create_bin_file(struct kobject *kobj,
           const struct bin_attribute *attr);
void sysfs_remove_bin_file(struct kobject *kobj,
      const 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 sysfs_rename_link_ns(struct kobject *kobj, struct kobject *target,
    const char *old_name, const char *new_name,
    const void *new_ns);

void sysfs_delete_link(struct kobject *dir, struct kobject *targ,
   const char *name);

int __attribute__((warn_unused_result)) sysfs_create_group(struct kobject *kobj,
        const struct attribute_group *grp);
int __attribute__((warn_unused_result)) sysfs_create_groups(struct kobject *kobj,
         const struct attribute_group **groups);
int sysfs_update_group(struct kobject *kobj,
         const struct attribute_group *grp);
void sysfs_remove_group(struct kobject *kobj,
   const struct attribute_group *grp);
void sysfs_remove_groups(struct kobject *kobj,
    const struct attribute_group **groups);
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);
int sysfs_merge_group(struct kobject *kobj,
         const struct attribute_group *grp);
void sysfs_unmerge_group(struct kobject *kobj,
         const struct attribute_group *grp);
int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
       struct kobject *target, const char *link_name);
void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
      const char *link_name);

void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);

int __attribute__((warn_unused_result)) sysfs_init(void);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sysfs_enable_ns(struct kernfs_node *kn)
{
 return kernfs_enable_ns(kn);
}
# 455 "include/linux/sysfs.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) sysfs_create_file(struct kobject *kobj,
       const struct attribute *attr)
{
 return sysfs_create_file_ns(kobj, attr, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sysfs_remove_file(struct kobject *kobj,
         const struct attribute *attr)
{
 sysfs_remove_file_ns(kobj, attr, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int sysfs_rename_link(struct kobject *kobj, struct kobject *target,
        const char *old_name, const char *new_name)
{
 return sysfs_rename_link_ns(kobj, target, old_name, new_name, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sysfs_notify_dirent(struct kernfs_node *kn)
{
 kernfs_notify(kn);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kernfs_node *sysfs_get_dirent(struct kernfs_node *parent,
         const unsigned char *name)
{
 return kernfs_find_and_get(parent, name);
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct kernfs_node *sysfs_get(struct kernfs_node *kn)
{
 kernfs_get(kn);
 return kn;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void sysfs_put(struct kernfs_node *kn)
{
 kernfs_put(kn);
}
# 22 "include/linux/kobject.h" 2


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





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kref_init(struct kref *kref)
{
 (((&kref->refcount)->counter) = (1));
}





static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void kref_get(struct kref *kref)
{




 ({ static bool __attribute__ ((__section__(".data.unlikely"))) __warned; int __ret_warn_once = !!((atomic_add_return(1, &kref->refcount)) < 2); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/kref.h", 47); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
}
# 68 "include/linux/kref.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kref_sub(struct kref *kref, unsigned int count,
      void (*release)(struct kref *kref))
{
 ({ int __ret_warn_on = !!(release == ((void *)0)); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/kref.h", 71); __builtin_expect(!!(__ret_warn_on), 0); });

 if ((atomic_sub_return((int) count, &kref->refcount) == 0)) {
  release(kref);
  return 1;
 }
 return 0;
}
# 97 "include/linux/kref.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kref_put(struct kref *kref, void (*release)(struct kref *kref))
{
 return kref_sub(kref, 1, release);
}
# 115 "include/linux/kref.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kref_put_spinlock_irqsave(struct kref *kref,
  void (*release)(struct kref *kref),
  spinlock_t *lock)
{
 unsigned long flags;

 ({ int __ret_warn_on = !!(release == ((void *)0)); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/kref.h", 121); __builtin_expect(!!(__ret_warn_on), 0); });
 if (atomic_add_unless(&kref->refcount, -1, 1))
  return 0;
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(lock)); } while (0); } while (0);
 if ((atomic_sub_return(1, &kref->refcount) == 0)) {
  release(kref);
  do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } while (0);
  return 1;
 }
 spin_unlock_irqrestore(lock, flags);
 return 0;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int kref_put_mutex(struct kref *kref,
     void (*release)(struct kref *kref),
     struct mutex *lock)
{
 ({ int __ret_warn_on = !!(release == ((void *)0)); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("include/linux/kref.h", 138); __builtin_expect(!!(__ret_warn_on), 0); });
 if (__builtin_expect(!!(!atomic_add_unless(&kref->refcount, -1, 1)), 0)) {
  mutex_lock(lock);
  if (__builtin_expect(!!(!(atomic_sub_return(1, &kref->refcount) == 0)), 0)) {
   mutex_unlock(lock);
   return 0;
  }
  release(kref);
  return 1;
 }
 return 0;
}
# 167 "include/linux/kref.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) kref_get_unless_zero(struct kref *kref)
{
 return atomic_add_unless(&kref->refcount, 1, 0);
}
# 25 "include/linux/kobject.h" 2
# 37 "include/linux/kobject.h"
extern char uevent_helper[];



extern u64 uevent_seqnum;
# 53 "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 kernfs_node *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 __attribute__((format(printf, 2, 3)))
int kobject_set_name(struct kobject *kobj, const char *name, ...);
extern int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
      va_list vargs);

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

extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
extern __attribute__((format(printf, 3, 4))) __attribute__((warn_unused_result))
int kobject_add(struct kobject *kobj, struct kobject *parent,
  const char *fmt, ...);
extern __attribute__((format(printf, 4, 5))) __attribute__((warn_unused_result))
int 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 const void *kobject_namespace(struct kobject *kobj);
extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);

struct kobj_type {
 void (*release)(struct kobject *kobj);
 const struct sysfs_ops *sysfs_ops;
 struct attribute **default_attrs;
 const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
 const void *(*namespace)(struct kobject *kobj);
};

struct kobj_uevent_env {
 char *argv[3];
 char *envp[32];
 int envp_idx;
 char buf[2048];
 int buflen;
};

struct kset_uevent_ops {
 int (* const filter)(struct kset *kset, struct kobject *kobj);
 const char *(* const name)(struct kset *kset, struct kobject *kobj);
 int (* const 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 const struct sysfs_ops kobj_sysfs_ops;

struct sock;
# 167 "include/linux/kobject.h"
struct kset {
 struct list_head list;
 spinlock_t list_lock;
 struct kobject kobj;
 const 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,
      const struct kset_uevent_ops *u,
      struct kobject *parent_kobj);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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)) __attribute__((no_instrument_function)) struct kset *kset_get(struct kset *k)
{
 return k ? to_kset(kobject_get(&k->kobj)) : ((void *)0);
}

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

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) 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;

int kobject_uevent(struct kobject *kobj, enum kobject_action action);
int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
   char *envp[]);

__attribute__((format(printf, 2, 3)))
int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...);

int kobject_action_type(const char *buf, size_t count,
   enum kobject_action *type);
# 18 "include/linux/device.h" 2
# 1 "include/linux/klist.h" 1
# 19 "include/linux/klist.h"
struct klist_node;
struct klist {
 spinlock_t k_lock;
 struct list_head k_list;
 void (*get)(struct klist_node *);
 void (*put)(struct klist_node *);
} __attribute__ ((aligned (sizeof(void *))));
# 36 "include/linux/klist.h"
extern void klist_init(struct klist *k, void (*get)(struct klist_node *),
         void (*put)(struct klist_node *));

struct klist_node {
 void *n_klist;
 struct list_head n_node;
 struct kref n_ref;
};

extern void klist_add_tail(struct klist_node *n, struct klist *k);
extern void klist_add_head(struct klist_node *n, struct klist *k);
extern void klist_add_behind(struct klist_node *n, struct klist_node *pos);
extern void klist_add_before(struct klist_node *n, struct klist_node *pos);

extern void klist_del(struct klist_node *n);
extern void klist_remove(struct klist_node *n);

extern int klist_node_attached(struct klist_node *n);


struct klist_iter {
 struct klist *i_klist;
 struct klist_node *i_cur;
};


extern void klist_iter_init(struct klist *k, struct klist_iter *i);
extern void klist_iter_init_node(struct klist *k, struct klist_iter *i,
     struct klist_node *n);
extern void klist_iter_exit(struct klist_iter *i);
extern struct klist_node *klist_next(struct klist_iter *i);
# 19 "include/linux/device.h" 2





# 1 "include/linux/pinctrl/devinfo.h" 1
# 21 "include/linux/pinctrl/devinfo.h"
# 1 "include/linux/pinctrl/consumer.h" 1
# 18 "include/linux/pinctrl/consumer.h"
# 1 "include/linux/pinctrl/pinctrl-state.h" 1
# 19 "include/linux/pinctrl/consumer.h" 2


struct pinctrl;
struct pinctrl_state;
struct device;




extern int pinctrl_request_gpio(unsigned gpio);
extern void pinctrl_free_gpio(unsigned gpio);
extern int pinctrl_gpio_direction_input(unsigned gpio);
extern int pinctrl_gpio_direction_output(unsigned gpio);

extern struct pinctrl * __attribute__((warn_unused_result)) pinctrl_get(struct device *dev);
extern void pinctrl_put(struct pinctrl *p);
extern struct pinctrl_state * __attribute__((warn_unused_result)) pinctrl_lookup_state(
       struct pinctrl *p,
       const char *name);
extern int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *s);

extern struct pinctrl * __attribute__((warn_unused_result)) devm_pinctrl_get(struct device *dev);
extern void devm_pinctrl_put(struct pinctrl *p);


extern int pinctrl_pm_select_default_state(struct device *dev);
extern int pinctrl_pm_select_sleep_state(struct device *dev);
extern int pinctrl_pm_select_idle_state(struct device *dev);
# 131 "include/linux/pinctrl/consumer.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct pinctrl * __attribute__((warn_unused_result)) pinctrl_get_select(
     struct device *dev, const char *name)
{
 struct pinctrl *p;
 struct pinctrl_state *s;
 int ret;

 p = pinctrl_get(dev);
 if (IS_ERR(p))
  return p;

 s = pinctrl_lookup_state(p, name);
 if (IS_ERR(s)) {
  pinctrl_put(p);
  return ERR_PTR(PTR_ERR(s));
 }

 ret = pinctrl_select_state(p, s);
 if (ret < 0) {
  pinctrl_put(p);
  return ERR_PTR(ret);
 }

 return p;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct pinctrl * __attribute__((warn_unused_result)) pinctrl_get_select_default(
     struct device *dev)
{
 return pinctrl_get_select(dev, "default");
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct pinctrl * __attribute__((warn_unused_result)) devm_pinctrl_get_select(
     struct device *dev, const char *name)
{
 struct pinctrl *p;
 struct pinctrl_state *s;
 int ret;

 p = devm_pinctrl_get(dev);
 if (IS_ERR(p))
  return p;

 s = pinctrl_lookup_state(p, name);
 if (IS_ERR(s)) {
  devm_pinctrl_put(p);
  return ERR_CAST(s);
 }

 ret = pinctrl_select_state(p, s);
 if (ret < 0) {
  devm_pinctrl_put(p);
  return ERR_PTR(ret);
 }

 return p;
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) struct pinctrl * __attribute__((warn_unused_result)) devm_pinctrl_get_select_default(
     struct device *dev)
{
 return devm_pinctrl_get_select(dev, "default");
}
# 22 "include/linux/pinctrl/devinfo.h" 2






struct dev_pin_info {
 struct pinctrl *p;
 struct pinctrl_state *default_state;

 struct pinctrl_state *sleep_state;
 struct pinctrl_state *idle_state;

};

extern int pinctrl_bind_pins(struct device *dev);
# 25 "include/linux/device.h" 2
# 1 "include/linux/pm.h" 1
# 34 "include/linux/pm.h"
extern void (*pm_power_off)(void);
extern void (*pm_power_off_prepare)(void);

struct device;

extern void pm_vt_switch_required(struct device *dev, bool required);
extern void pm_vt_switch_unregister(struct device *dev);
# 54 "include/linux/pm.h"
struct device;


extern const char power_group_name[];




typedef struct pm_message {
 int event;
} pm_message_t;
# 295 "include/linux/pm.h"
struct dev_pm_ops {
 int (*prepare)(struct device *dev);
 void (*complete)(struct device *dev);
 int (*suspend)(struct device *dev);
 int (*resume)(struct device *dev);
 int (*freeze)(struct device *dev);
 int (*thaw)(struct device *dev);
 int (*poweroff)(struct device *dev);
 int (*restore)(struct device *dev);
 int (*suspend_late)(struct device *dev);
 int (*resume_early)(struct device *dev);
 int (*freeze_late)(struct device *dev);
 int (*thaw_early)(struct device *dev);
 int (*poweroff_late)(struct device *dev);
 int (*restore_early)(struct device *dev);
 int (*suspend_noirq)(struct device *dev);
 int (*resume_noirq)(struct device *dev);
 int (*freeze_noirq)(struct device *dev);
 int (*thaw_noirq)(struct device *dev);
 int (*poweroff_noirq)(struct device *dev);
 int (*restore_noirq)(struct device *dev);
 int (*runtime_suspend)(struct device *dev);
 int (*runtime_resume)(struct device *dev);
 int (*runtime_idle)(struct device *dev);
};
# 501 "include/linux/pm.h"
enum rpm_status {
 RPM_ACTIVE = 0,
 RPM_RESUMING,
 RPM_SUSPENDED,
 RPM_SUSPENDING,
};
# 523 "include/linux/pm.h"
enum rpm_request {
 RPM_REQ_NONE = 0,
 RPM_REQ_IDLE,
 RPM_REQ_SUSPEND,
 RPM_REQ_AUTOSUSPEND,
 RPM_REQ_RESUME,
};

struct wakeup_source;
struct pm_domain_data;

struct pm_subsys_data {
 spinlock_t lock;
 unsigned int refcount;

 struct list_head clock_list;


 struct pm_domain_data *domain_data;

};

struct dev_pm_info {
 pm_message_t power_state;
 unsigned int can_wakeup:1;
 unsigned int async_suspend:1;
 bool is_prepared:1;
 bool is_suspended:1;
 bool is_noirq_suspended:1;
 bool is_late_suspended:1;
 bool ignore_children:1;
 bool early_init:1;
 bool direct_complete:1;
 spinlock_t lock;

 struct list_head entry;
 struct completion completion;
 struct wakeup_source *wakeup;
 bool wakeup_path:1;
 bool syscore:1;




 struct timer_list suspend_timer;
 unsigned long timer_expires;
 struct work_struct work;
 wait_queue_head_t wait_queue;
 atomic_t usage_count;
 atomic_t child_count;
 unsigned int disable_depth:3;
 unsigned int idle_notification:1;
 unsigned int request_pending:1;
 unsigned int deferred_resume:1;
 unsigned int run_wake:1;
 unsigned int runtime_auto:1;
 unsigned int no_callbacks:1;
 unsigned int irq_safe:1;
 unsigned int use_autosuspend:1;
 unsigned int timer_autosuspends:1;
 unsigned int memalloc_noio:1;
 enum rpm_request request;
 enum rpm_status runtime_status;
 int runtime_error;
 int autosuspend_delay;
 unsigned long last_busy;
 unsigned long active_jiffies;
 unsigned long suspended_jiffies;
 unsigned long accounting_timestamp;

 struct pm_subsys_data *subsys_data;
 void (*set_latency_tolerance)(struct device *, s32);
 struct dev_pm_qos *qos;
};

extern void update_pm_runtime_accounting(struct device *dev);
extern int dev_pm_get_subsys_data(struct device *dev);
extern void dev_pm_put_subsys_data(struct device *dev);
# 612 "include/linux/pm.h"
struct dev_pm_domain {
 struct dev_pm_ops ops;
 void (*detach)(struct device *dev, bool power_off);
 int (*activate)(struct device *dev);
 void (*sync)(struct device *dev);
 void (*dismiss)(struct device *dev);
};
# 675 "include/linux/pm.h"
extern void device_pm_lock(void);
extern void dpm_resume_start(pm_message_t state);
extern void dpm_resume_end(pm_message_t state);
extern void dpm_resume_noirq(pm_message_t state);
extern void dpm_resume_early(pm_message_t state);
extern void dpm_resume(pm_message_t state);
extern void dpm_complete(pm_message_t state);

extern void device_pm_unlock(void);
extern int dpm_suspend_end(pm_message_t state);
extern int dpm_suspend_start(pm_message_t state);
extern int dpm_suspend_noirq(pm_message_t state);
extern int dpm_suspend_late(pm_message_t state);
extern int dpm_suspend(pm_message_t state);
extern int dpm_prepare(pm_message_t state);

extern void __suspend_report_result(const char *function, void *fn, int ret);






extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
extern void dpm_for_each_dev(void *data, void (*fn)(struct device *, void *));

extern int pm_generic_prepare(struct device *dev);
extern int pm_generic_suspend_late(struct device *dev);
extern int pm_generic_suspend_noirq(struct device *dev);
extern int pm_generic_suspend(struct device *dev);
extern int pm_generic_resume_early(struct device *dev);
extern int pm_generic_resume_noirq(struct device *dev);
extern int pm_generic_resume(struct device *dev);
extern int pm_generic_freeze_noirq(struct device *dev);
extern int pm_generic_freeze_late(struct device *dev);
extern int pm_generic_freeze(struct device *dev);
extern int pm_generic_thaw_noirq(struct device *dev);
extern int pm_generic_thaw_early(struct device *dev);
extern int pm_generic_thaw(struct device *dev);
extern int pm_generic_restore_noirq(struct device *dev);
extern int pm_generic_restore_early(struct device *dev);
extern int pm_generic_restore(struct device *dev);
extern int pm_generic_poweroff_noirq(struct device *dev);
extern int pm_generic_poweroff_late(struct device *dev);
extern int pm_generic_poweroff(struct device *dev);
extern void pm_generic_complete(struct device *dev);
# 766 "include/linux/pm.h"
enum dpm_order {
 DPM_ORDER_NONE,
 DPM_ORDER_DEV_AFTER_PARENT,
 DPM_ORDER_PARENT_BEFORE_DEV,
 DPM_ORDER_DEV_LAST,
};
# 26 "include/linux/device.h" 2

# 1 "include/linux/ratelimit.h" 1
# 10 "include/linux/ratelimit.h"
struct ratelimit_state {
 raw_spinlock_t lock;

 int interval;
 int burst;
 int printed;
 int missed;
 unsigned long begin;
};
# 34 "include/linux/ratelimit.h"
static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void ratelimit_state_init(struct ratelimit_state *rs,
     int interval, int burst)
{
 do { static struct lock_class_key __key; __raw_spin_lock_init((&rs->lock), "&rs->lock", &__key); } while (0);
 rs->interval = interval;
 rs->burst = burst;
 rs->printed = 0;
 rs->missed = 0;
 rs->begin = 0;
}

extern struct ratelimit_state printk_ratelimit_state;

extern int ___ratelimit(struct ratelimit_state *rs, const char *func);
# 28 "include/linux/device.h" 2


# 1 "./arch/arm/include/asm/device.h" 1
# 9 "./arch/arm/include/asm/device.h"
struct dev_archdata {
 struct dma_map_ops *dma_ops;
# 20 "./arch/arm/include/asm/device.h"
 bool dma_coherent;
};

struct omap_device;

struct pdev_archdata {



};
# 31 "include/linux/device.h" 2

struct device;
struct device_private;
struct device_driver;
struct driver_private;
struct module;
struct class;
struct subsys_private;
struct bus_type;
struct device_node;
struct fwnode_handle;
struct iommu_ops;
struct iommu_group;

struct bus_attribute {
 struct attribute attr;
 ssize_t (*show)(struct bus_type *bus, char *buf);
 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};
# 58 "include/linux/device.h"
extern int __attribute__((warn_unused_result)) bus_create_file(struct bus_type *,
     struct bus_attribute *);
extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
# 105 "include/linux/device.h"
struct bus_type {
 const char *name;
 const char *dev_name;
 struct device *dev_root;
 struct device_attribute *dev_attrs;
 const struct attribute_group **bus_groups;
 const struct attribute_group **dev_groups;
 const struct attribute_group **drv_groups;

 int (*match)(struct device *dev, struct device_driver *drv);
 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
 int (*probe)(struct device *dev);
 int (*remove)(struct device *dev);
 void (*shutdown)(struct device *dev);

 int (*online)(struct device *dev);
 int (*offline)(struct device *dev);

 int (*suspend)(struct device *dev, pm_message_t state);
 int (*resume)(struct device *dev);

 const struct dev_pm_ops *pm;

 const struct iommu_ops *iommu_ops;

 struct subsys_private *p;
 struct lock_class_key lock_key;
};

extern int __attribute__((warn_unused_result)) bus_register(struct bus_type *bus);

extern void bus_unregister(struct bus_type *bus);

extern int __attribute__((warn_unused_result)) bus_rescan_devices(struct bus_type *bus);


struct subsys_dev_iter {
 struct klist_iter ki;
 const struct device_type *type;
};
void subsys_dev_iter_init(struct subsys_dev_iter *iter,
    struct bus_type *subsys,
    struct device *start,
    const struct device_type *type);
struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
void subsys_dev_iter_exit(struct subsys_dev_iter *iter);

int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
       int (*fn)(struct device *dev, void *data));
struct device *bus_find_device(struct bus_type *bus, struct device *start,
          void *data,
          int (*match)(struct device *dev, void *data));
struct device *bus_find_device_by_name(struct bus_type *bus,
           struct device *start,
           const char *name);
struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
     struct device *hint);
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
       void *data, int (*fn)(struct device_driver *, void *));
void bus_sort_breadthfirst(struct bus_type *bus,
      int (*compare)(const struct device *a,
       const struct device *b));






struct notifier_block;

extern int bus_register_notifier(struct bus_type *bus,
     struct notifier_block *nb);
extern int bus_unregister_notifier(struct bus_type *bus,
       struct notifier_block *nb);
# 195 "include/linux/device.h"
extern struct kset *bus_get_kset(struct bus_type *bus);
extern struct klist *bus_get_device_klist(struct bus_type *bus);
# 230 "include/linux/device.h"
struct device_driver {
 const char *name;
 struct bus_type *bus;

 struct module *owner;
 const char *mod_name;

 bool suppress_bind_attrs;

 const struct of_device_id *of_match_table;
 const struct acpi_device_id *acpi_match_table;

 int (*probe) (struct device *dev);
 int (*remove) (struct device *dev);
 void (*shutdown) (struct device *dev);
 int (*suspend) (struct device *dev, pm_message_t state);
 int (*resume) (struct device *dev);
 const struct attribute_group **groups;

 const struct dev_pm_ops *pm;

 struct driver_private *p;
};


extern int __attribute__((warn_unused_result)) driver_register(struct device_driver *drv);
extern void driver_unregister(struct device_driver *drv);

extern struct device_driver *driver_find(const char *name,
      struct bus_type *bus);
extern int driver_probe_done(void);
extern void wait_for_device_probe(void);




struct driver_attribute {
 struct attribute attr;
 ssize_t (*show)(struct device_driver *driver, char *buf);
 ssize_t (*store)(struct device_driver *driver, const char *buf,
    size_t count);
};
# 282 "include/linux/device.h"
extern int __attribute__((warn_unused_result)) driver_create_file(struct device_driver *driver,
     const struct driver_attribute *attr);
extern void driver_remove_file(struct device_driver *driver,
          const struct driver_attribute *attr);

extern int __attribute__((warn_unused_result)) driver_for_each_device(struct device_driver *drv,
            struct device *start,
            void *data,
            int (*fn)(struct device *dev,
        void *));
struct device *driver_find_device(struct device_driver *drv,
      struct device *start, void *data,
      int (*match)(struct device *dev, void *data));
# 309 "include/linux/device.h"
struct subsys_interface {
 const char *name;
 struct bus_type *subsys;
 struct list_head node;
 int (*add_dev)(struct device *dev, struct subsys_interface *sif);
 int (*remove_dev)(struct device *dev, struct subsys_interface *sif);
};

int subsys_interface_register(struct subsys_interface *sif);
void subsys_interface_unregister(struct subsys_interface *sif);

int subsys_system_register(struct bus_type *subsys,
      const struct attribute_group **groups);
int subsys_virtual_register(struct bus_type *subsys,
       const struct attribute_group **groups);
# 353 "include/linux/device.h"
struct class {
 const char *name;
 struct module *owner;

 struct class_attribute *class_attrs;
 const struct attribute_group **dev_groups;
 struct kobject *dev_kobj;

 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
 char *(*devnode)(struct device *dev, umode_t *mode);

 void (*class_release)(struct class *class);
 void (*dev_release)(struct device *dev);

 int (*suspend)(struct device *dev, pm_message_t state);
 int (*resume)(struct device *dev);

 const struct kobj_ns_type_operations *ns_type;
 const void *(*namespace)(struct device *dev);

 const struct dev_pm_ops *pm;

 struct subsys_private *p;
};

struct class_dev_iter {
 struct klist_iter ki;
 const struct device_type *type;
};

extern struct kobject *sysfs_dev_block_kobj;
extern struct kobject *sysfs_dev_char_kobj;
extern int __attribute__((warn_unused_result)) __class_register(struct class *class,
      struct lock_class_key *key);
extern void class_unregister(struct class *class);
# 397 "include/linux/device.h"
struct class_compat;
struct class_compat *class_compat_register(const char *name);
void class_compat_unregister(struct class_compat *cls);
int class_compat_create_link(struct class_compat *cls, struct device *dev,
        struct device *device_link);
void class_compat_remove_link(struct class_compat *cls, struct device *dev,
         struct device *device_link);

extern void class_dev_iter_init(struct class_dev_iter *iter,
    struct class *class,
    struct device *start,
    const struct device_type *type);
extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
extern void class_dev_iter_exit(struct class_dev_iter *iter);

extern int class_for_each_device(struct class *class, struct device *start,
     void *data,
     int (*fn)(struct device *dev, void *data));
extern struct device *class_find_device(struct class *class,
     struct device *start, const void *data,
     int (*match)(struct device *, const void *));

struct class_attribute {
 struct attribute attr;
 ssize_t (*show)(struct class *class, struct class_attribute *attr,
   char *buf);
 ssize_t (*store)(struct class *class, struct class_attribute *attr,
   const char *buf, size_t count);
};
# 434 "include/linux/device.h"
extern int __attribute__((warn_unused_result)) class_create_file_ns(struct class *class,
          const struct class_attribute *attr,
          const void *ns);
extern void class_remove_file_ns(struct class *class,
     const struct class_attribute *attr,
     const void *ns);

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) int __attribute__((warn_unused_result)) class_create_file(struct class *class,
     const struct class_attribute *attr)
{
 return class_create_file_ns(class, attr, ((void *)0));
}

static inline __attribute__((always_inline)) __attribute__((no_instrument_function)) void class_remove_file(struct class *class,
         const struct class_attribute *attr)
{
 return class_remove_file_ns(class, attr, ((void *)0));
}


struct class_attribute_string {
 struct class_attribute attr;
 char *str;
};
# 466 "include/linux/device.h"
extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
                        char *buf);

struct class_interface {
 struct list_head node;
 struct class *class;

 int (*add_dev) (struct device *, struct class_interface *);
 void (*remove_dev) (struct device *, struct class_interface *);
};

extern int __attribute__((warn_unused_result)) class_interface_register(struct class_interface *);
extern void class_interface_unregister(struct class_interface *);

extern struct class * __attribute__((warn_unused_result)) __class_create(struct module *owner,
        const char *name,
        struct lock_class_key *key);
extern void class_destroy(struct class *cls);
# 502 "include/linux/device.h"
struct device_type {
 const char *name;
 const struct attribute_group **groups;
 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
 char *(*devnode)(struct device *dev, umode_t *mode,
    kuid_t *uid, kgid_t *gid);
 void (*release)(struct device *dev);

 const struct dev_pm_ops *pm;
};


struct device_attribute {
 struct attribute attr;
 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
   char *buf);
 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
    const char *buf, size_t count);
};

struct dev_ext_attribute {
 struct device_attribute attr;
 void *var;
};

ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
     char *buf);
ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
      const char *buf, size_t count);
ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
   char *buf);
ssize_t device_st