Attachment 274801 Details for Bug 407281 – pre-processed hrtimer.c

pre-processed hrtimer.c

hrtimer.i (text/plain), 441.78 KB, created by Marc Dionne on 2007-12-01 20:18:07 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Marc Dionne

Created: 2007-12-01 20:18:07 UTC

Size: 441.78 KB

patch

obsolete

># 1 "kernel/hrtimer.c"
># 1 "/s/kernel/linux-2.6//"
># 1 "<built-in>"
># 1 "<command line>"
># 1 "./include/linux/autoconf.h" 1
># 1 "<command line>" 2
># 1 "kernel/hrtimer.c"
># 34 "kernel/hrtimer.c"
># 1 "include/linux/cpu.h" 1
># 22 "include/linux/cpu.h"
># 1 "include/linux/sysdev.h" 1
># 24 "include/linux/sysdev.h"
># 1 "include/linux/kobject.h" 1
># 22 "include/linux/kobject.h"
># 1 "include/linux/types.h" 1
># 11 "include/linux/types.h"
># 1 "include/linux/posix_types.h" 1
>
>
>
># 1 "include/linux/stddef.h" 1
>
>
>
># 1 "include/linux/compiler.h" 1
># 40 "include/linux/compiler.h"
># 1 "include/linux/compiler-gcc4.h" 1
>
>
>
>
>
># 1 "include/linux/compiler-gcc.h" 1
># 7 "include/linux/compiler-gcc4.h" 2
># 41 "include/linux/compiler.h" 2
># 5 "include/linux/stddef.h" 2
># 15 "include/linux/stddef.h"
>enum {
> false = 0,
> true = 1
>};
># 5 "include/linux/posix_types.h" 2
># 36 "include/linux/posix_types.h"
>typedef struct {
> unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
>} __kernel_fd_set;
>
>
>typedef void (*__kernel_sighandler_t)(int);
>
>
>typedef int __kernel_key_t;
>typedef int __kernel_mqd_t;
>
># 1 "include/asm/posix_types.h" 1
>
>
># 1 "include/asm/posix_types_32.h" 1
># 10 "include/asm/posix_types_32.h"
>typedef unsigned long __kernel_ino_t;
>typedef unsigned short __kernel_mode_t;
>typedef unsigned short __kernel_nlink_t;
>typedef long __kernel_off_t;
>typedef int __kernel_pid_t;
>typedef unsigned short __kernel_ipc_pid_t;
>typedef unsigned short __kernel_uid_t;
>typedef unsigned short __kernel_gid_t;
>typedef unsigned int __kernel_size_t;
>typedef int __kernel_ssize_t;
>typedef int __kernel_ptrdiff_t;
>typedef long __kernel_time_t;
>typedef long __kernel_suseconds_t;
>typedef long __kernel_clock_t;
>typedef int __kernel_timer_t;
>typedef int __kernel_clockid_t;
>typedef int __kernel_daddr_t;
>typedef char * __kernel_caddr_t;
>typedef unsigned short __kernel_uid16_t;
>typedef unsigned short __kernel_gid16_t;
>typedef unsigned int __kernel_uid32_t;
>typedef unsigned int __kernel_gid32_t;
>
>typedef unsigned short __kernel_old_uid_t;
>typedef unsigned short __kernel_old_gid_t;
>typedef unsigned short __kernel_old_dev_t;
>
>
>typedef long long __kernel_loff_t;
>
>
>typedef struct {
>
> int val[2];
>
>
>
>} __kernel_fsid_t;
># 4 "include/asm/posix_types.h" 2
># 48 "include/linux/posix_types.h" 2
># 12 "include/linux/types.h" 2
># 1 "include/asm/types.h" 1
>
>
>
>
>
>typedef unsigned short umode_t;
>
>
>
>
>
>
>typedef __signed__ char __s8;
>typedef unsigned char __u8;
>
>typedef __signed__ short __s16;
>typedef unsigned short __u16;
>
>typedef __signed__ int __s32;
>typedef unsigned int __u32;
>
>
>
>__extension__ typedef __signed__ long long __s64;
>__extension__ typedef unsigned long long __u64;
># 47 "include/asm/types.h"
>typedef signed char s8;
>typedef unsigned char u8;
>
>typedef signed short s16;
>typedef unsigned short u16;
>
>typedef signed int s32;
>typedef unsigned int u32;
>
>typedef signed long long s64;
>typedef unsigned long long u64;
>
>typedef u64 dma64_addr_t;
>
>
>
>
>typedef u32 dma_addr_t;
># 13 "include/linux/types.h" 2
>
>
>
>typedef __u32 __kernel_dev_t;
>
>typedef __kernel_fd_set fd_set;
>typedef __kernel_dev_t dev_t;
>typedef __kernel_ino_t ino_t;
>typedef __kernel_mode_t mode_t;
>typedef __kernel_nlink_t nlink_t;
>typedef __kernel_off_t off_t;
>typedef __kernel_pid_t pid_t;
>typedef __kernel_daddr_t daddr_t;
>typedef __kernel_key_t key_t;
>typedef __kernel_suseconds_t suseconds_t;
>typedef __kernel_timer_t timer_t;
>typedef __kernel_clockid_t clockid_t;
>typedef __kernel_mqd_t mqd_t;
>
>
>typedef _Bool bool;
>
>typedef __kernel_uid32_t uid_t;
>typedef __kernel_gid32_t gid_t;
>typedef __kernel_uid16_t uid16_t;
>typedef __kernel_gid16_t gid16_t;
>
>typedef unsigned long uintptr_t;
>
>
>
>typedef __kernel_old_uid_t old_uid_t;
>typedef __kernel_old_gid_t old_gid_t;
># 57 "include/linux/types.h"
>typedef __kernel_loff_t loff_t;
># 66 "include/linux/types.h"
>typedef __kernel_size_t size_t;
>
>
>
>
>typedef __kernel_ssize_t ssize_t;
>
>
>
>
>typedef __kernel_ptrdiff_t ptrdiff_t;
>
>
>
>
>typedef __kernel_time_t time_t;
>
>
>
>
>typedef __kernel_clock_t clock_t;
>
>
>
>
>typedef __kernel_caddr_t caddr_t;
>
>
>
>typedef unsigned char u_char;
>typedef unsigned short u_short;
>typedef unsigned int u_int;
>typedef unsigned long u_long;
>
>
>typedef unsigned char unchar;
>typedef unsigned short ushort;
>typedef unsigned int uint;
>typedef unsigned long ulong;
>
>
>
>
>typedef __u8 u_int8_t;
>typedef __s8 int8_t;
>typedef __u16 u_int16_t;
>typedef __s16 int16_t;
>typedef __u32 u_int32_t;
>typedef __s32 int32_t;
>
>
>
>typedef __u8 uint8_t;
>typedef __u16 uint16_t;
>typedef __u32 uint32_t;
>
>
>typedef __u64 uint64_t;
>typedef __u64 u_int64_t;
>typedef __s64 int64_t;
># 140 "include/linux/types.h"
>typedef u64 sector_t;
># 149 "include/linux/types.h"
>typedef u64 blkcnt_t;
># 180 "include/linux/types.h"
>typedef __u16 __le16;
>typedef __u16 __be16;
>typedef __u32 __le32;
>typedef __u32 __be32;
>
>typedef __u64 __le64;
>typedef __u64 __be64;
>
>typedef __u16 __sum16;
>typedef __u32 __wsum;
>
>
>typedef unsigned gfp_t;
>
>
>typedef u64 resource_size_t;
>
>
>
>
>
>
>struct ustat {
> __kernel_daddr_t f_tfree;
> __kernel_ino_t f_tinode;
> char f_fname[6];
> char f_fpack[6];
>};
># 23 "include/linux/kobject.h" 2
># 1 "include/linux/list.h" 1
>
>
>
>
>
>
># 1 "include/linux/poison.h" 1
># 8 "include/linux/list.h" 2
># 1 "include/linux/prefetch.h" 1
># 14 "include/linux/prefetch.h"
># 1 "include/asm/processor.h" 1
>
># 1 "include/asm/processor_32.h" 1
># 10 "include/asm/processor_32.h"
># 1 "include/asm/vm86.h" 1
># 72 "include/asm/vm86.h"
>struct vm86_regs {
>
>
>
> long ebx;
> long ecx;
> long edx;
> long esi;
> long edi;
> long ebp;
> long eax;
> long __null_ds;
> long __null_es;
> long __null_fs;
> long __null_gs;
> long orig_eax;
> long eip;
> unsigned short cs, __csh;
> long eflags;
> long esp;
> unsigned short ss, __ssh;
>
>
>
> unsigned short es, __esh;
> unsigned short ds, __dsh;
> unsigned short fs, __fsh;
> unsigned short gs, __gsh;
>};
>
>struct revectored_struct {
> unsigned long __map[8];
>};
>
>struct vm86_struct {
> struct vm86_regs regs;
> unsigned long flags;
> unsigned long screen_bitmap;
> unsigned long cpu_type;
> struct revectored_struct int_revectored;
> struct revectored_struct int21_revectored;
>};
>
>
>
>
>
>
>struct vm86plus_info_struct {
> unsigned long force_return_for_pic:1;
> unsigned long vm86dbg_active:1;
> unsigned long vm86dbg_TFpendig:1;
> unsigned long unused:28;
> unsigned long is_vm86pus:1;
> unsigned char vm86dbg_intxxtab[32];
>};
>
>struct vm86plus_struct {
> struct vm86_regs regs;
> unsigned long flags;
> unsigned long screen_bitmap;
> unsigned long cpu_type;
> struct revectored_struct int_revectored;
> struct revectored_struct int21_revectored;
> struct vm86plus_info_struct vm86plus;
>};
># 148 "include/asm/vm86.h"
># 1 "include/asm/ptrace.h" 1
>
>
>
>
># 1 "include/asm/ptrace-abi.h" 1
># 6 "include/asm/ptrace.h" 2
>
>
>
>
>
>
>
>struct pt_regs {
> long ebx;
> long ecx;
> long edx;
> long esi;
> long edi;
> long ebp;
> long eax;
> int xds;
> int xes;
> int xfs;
>
> long orig_eax;
> long eip;
> int xcs;
> long eflags;
> long esp;
> int xss;
>};
>
>
>
># 1 "include/asm/vm86.h" 1
># 36 "include/asm/ptrace.h" 2
># 1 "include/asm/segment.h" 1
>
># 1 "include/asm/segment_32.h" 1
># 3 "include/asm/segment.h" 2
># 37 "include/asm/ptrace.h" 2
>
>struct task_struct;
>extern void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code);
># 48 "include/asm/ptrace.h"
>static inline __attribute__((always_inline)) int user_mode(struct pt_regs *regs)
>{
> return (regs->xcs & 0x3) == 0x3;
>}
>static inline __attribute__((always_inline)) int user_mode_vm(struct pt_regs *regs)
>{
> return ((regs->xcs & 0x3) | (regs->eflags & 0x00020000)) >= 0x3;
>}
>static inline __attribute__((always_inline)) int v8086_mode(struct pt_regs *regs)
>{
> return (regs->eflags & 0x00020000);
>}
>
>
>
>
>
>
>extern unsigned long profile_pc(struct pt_regs *regs);
># 149 "include/asm/vm86.h" 2
>
>struct kernel_vm86_regs {
>
>
>
> struct pt_regs pt;
>
>
>
> unsigned short es, __esh;
> unsigned short ds, __dsh;
> unsigned short fs, __fsh;
> unsigned short gs, __gsh;
>};
>
>struct kernel_vm86_struct {
> struct kernel_vm86_regs regs;
># 175 "include/asm/vm86.h"
> unsigned long flags;
> unsigned long screen_bitmap;
> unsigned long cpu_type;
> struct revectored_struct int_revectored;
> struct revectored_struct int21_revectored;
> struct vm86plus_info_struct vm86plus;
> struct pt_regs *regs32;
># 192 "include/asm/vm86.h"
>};
>
>
>
>void handle_vm86_fault(struct kernel_vm86_regs *, long);
>int handle_vm86_trap(struct kernel_vm86_regs *, long, int);
>
>struct task_struct;
>void release_vm86_irqs(struct task_struct *);
># 11 "include/asm/processor_32.h" 2
># 1 "include/asm/math_emu.h" 1
>
>
>
># 1 "include/asm/sigcontext.h" 1
># 22 "include/asm/sigcontext.h"
>struct _fpreg {
> unsigned short significand[4];
> unsigned short exponent;
>};
>
>struct _fpxreg {
> unsigned short significand[4];
> unsigned short exponent;
> unsigned short padding[3];
>};
>
>struct _xmmreg {
> unsigned long element[4];
>};
>
>struct _fpstate {
>
> unsigned long cw;
> unsigned long sw;
> unsigned long tag;
> unsigned long ipoff;
> unsigned long cssel;
> unsigned long dataoff;
> unsigned long datasel;
> struct _fpreg _st[8];
> unsigned short status;
> unsigned short magic;
>
>
> unsigned long _fxsr_env[6];
> unsigned long mxcsr;
> unsigned long reserved;
> struct _fpxreg _fxsr_st[8];
> struct _xmmreg _xmm[8];
> unsigned long padding[56];
>};
>
>
>
>struct sigcontext {
> unsigned short gs, __gsh;
> unsigned short fs, __fsh;
> unsigned short es, __esh;
> unsigned short ds, __dsh;
> unsigned long edi;
> unsigned long esi;
> unsigned long ebp;
> unsigned long esp;
> unsigned long ebx;
> unsigned long edx;
> unsigned long ecx;
> unsigned long eax;
> unsigned long trapno;
> unsigned long err;
> unsigned long eip;
> unsigned short cs, __csh;
> unsigned long eflags;
> unsigned long esp_at_signal;
> unsigned short ss, __ssh;
> struct _fpstate * fpstate;
> unsigned long oldmask;
> unsigned long cr2;
>};
># 5 "include/asm/math_emu.h" 2
>
>int restore_i387_soft(void *s387, struct _fpstate *buf);
>int save_i387_soft(void *s387, struct _fpstate *buf);
>
>
>
>
>
>struct info {
> long ___orig_eip;
> long ___ebx;
> long ___ecx;
> long ___edx;
> long ___esi;
> long ___edi;
> long ___ebp;
> long ___eax;
> long ___ds;
> long ___es;
> long ___fs;
> long ___orig_eax;
> long ___eip;
> long ___cs;
> long ___eflags;
> long ___esp;
> long ___ss;
> long ___vm86_es;
> long ___vm86_ds;
> long ___vm86_fs;
> long ___vm86_gs;
>};
># 12 "include/asm/processor_32.h" 2
># 1 "include/asm/segment.h" 1
># 13 "include/asm/processor_32.h" 2
># 1 "include/asm/page.h" 1
>
>
># 1 "include/asm/page_32.h" 1
># 44 "include/asm/page_32.h"
>extern int nx_enabled;
># 90 "include/asm/page_32.h"
>typedef struct { unsigned long pte_low; } pte_t;
>typedef struct { unsigned long pgd; } pgd_t;
>typedef struct { unsigned long pgprot; } pgprot_t;
>
>
>static inline __attribute__((always_inline)) unsigned long native_pgd_val(pgd_t pgd)
>{
> return pgd.pgd;
>}
>
>static inline __attribute__((always_inline)) unsigned long native_pte_val(pte_t pte)
>{
> return pte.pte_low;
>}
>
>static inline __attribute__((always_inline)) pgd_t native_make_pgd(unsigned long val)
>{
> return (pgd_t) { val };
>}
>
>static inline __attribute__((always_inline)) pte_t native_make_pte(unsigned long val)
>{
> return (pte_t) { .pte_low = val };
>}
>
>
># 1 "include/asm-generic/pgtable-nopmd.h" 1
>
>
>
>
>
># 1 "include/asm-generic/pgtable-nopud.h" 1
># 13 "include/asm-generic/pgtable-nopud.h"
>typedef struct { pgd_t pgd; } pud_t;
># 25 "include/asm-generic/pgtable-nopud.h"
>static inline __attribute__((always_inline)) int pgd_none(pgd_t pgd) { return 0; }
>static inline __attribute__((always_inline)) int pgd_bad(pgd_t pgd) { return 0; }
>static inline __attribute__((always_inline)) int pgd_present(pgd_t pgd) { return 1; }
>static inline __attribute__((always_inline)) void pgd_clear(pgd_t *pgd) { }
># 38 "include/asm-generic/pgtable-nopud.h"
>static inline __attribute__((always_inline)) pud_t * pud_offset(pgd_t * pgd, unsigned long address)
>{
> return (pud_t *)pgd;
>}
># 7 "include/asm-generic/pgtable-nopmd.h" 2
># 15 "include/asm-generic/pgtable-nopmd.h"
>typedef struct { pud_t pud; } pmd_t;
># 27 "include/asm-generic/pgtable-nopmd.h"
>static inline __attribute__((always_inline)) int pud_none(pud_t pud) { return 0; }
>static inline __attribute__((always_inline)) int pud_bad(pud_t pud) { return 0; }
>static inline __attribute__((always_inline)) int pud_present(pud_t pud) { return 1; }
>static inline __attribute__((always_inline)) void pud_clear(pud_t *pud) { }
># 41 "include/asm-generic/pgtable-nopmd.h"
>static inline __attribute__((always_inline)) pmd_t * pmd_offset(pud_t * pud, unsigned long address)
>{
> return (pmd_t *)pud;
>}
># 117 "include/asm/page_32.h" 2
># 158 "include/asm/page_32.h"
>struct vm_area_struct;
>
>
>
>
>
>extern unsigned int __VMALLOC_RESERVE;
>
>extern int sysctl_legacy_va_layout;
>
>extern int page_is_ram(unsigned long pagenr);
># 200 "include/asm/page_32.h"
># 1 "include/asm-generic/memory_model.h" 1
># 201 "include/asm/page_32.h" 2
># 1 "include/asm-generic/page.h" 1
># 10 "include/asm-generic/page.h"
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) int get_order(unsigned long size)
>{
> int order;
>
> size = (size - 1) >> (12 - 1);
> order = -1;
> do {
>  size >>= 1;
>  order++;
> } while (size);
> return order;
>}
># 202 "include/asm/page_32.h" 2
># 4 "include/asm/page.h" 2
># 14 "include/asm/processor_32.h" 2
>
>
># 1 "include/asm/cpufeature.h" 1
>
># 1 "include/asm/cpufeature_32.h" 1
># 11 "include/asm/cpufeature_32.h"
># 1 "include/linux/bitops.h" 1
># 17 "include/linux/bitops.h"
># 1 "include/asm/bitops.h" 1
>
># 1 "include/asm/bitops_32.h" 1
># 13 "include/asm/bitops_32.h"
># 1 "include/asm/alternative.h" 1
>
># 1 "include/asm/alternative_32.h" 1
>
>
>
>
>
>
>
>struct alt_instr {
> u8 *instr;
> u8 *replacement;
> u8 cpuid;
> u8 instrlen;
> u8 replacementlen;
> u8 pad;
>};
>
>extern void alternative_instructions(void);
>extern void apply_alternatives(struct alt_instr *start, struct alt_instr *end);
>
>struct module;
>
>extern void alternatives_smp_module_add(struct module *mod, char *name,
>     void *locks, void *locks_end,
>     void *text, void *text_end);
>extern void alternatives_smp_module_del(struct module *mod);
>extern void alternatives_smp_switch(int smp);
># 139 "include/asm/alternative_32.h"
>struct paravirt_patch_site;
>
>
>
>
>static inline __attribute__((always_inline)) void
>apply_paravirt(struct paravirt_patch_site *start,
>        struct paravirt_patch_site *end)
>{}
>
>
>
>
>extern void text_poke(void *addr, unsigned char *opcode, int len);
># 3 "include/asm/alternative.h" 2
># 14 "include/asm/bitops_32.h" 2
># 40 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void set_bit(int nr, volatile unsigned long * addr)
>{
> __asm__ __volatile__( ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; "
>  "btsl %1,%0"
>  :"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
>}
># 57 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void __set_bit(int nr, volatile unsigned long * addr)
>{
> __asm__(
>  "btsl %1,%0"
>  :"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
>}
># 75 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void clear_bit(int nr, volatile unsigned long * addr)
>{
> __asm__ __volatile__( ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; "
>  "btrl %1,%0"
>  :"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
>}
># 91 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void clear_bit_unlock(unsigned long nr, volatile unsigned long *addr)
>{
> __asm__ __volatile__("": : :"memory");
> clear_bit(nr, addr);
>}
>
>static inline __attribute__((always_inline)) void __clear_bit(int nr, volatile unsigned long * addr)
>{
> __asm__ __volatile__(
>  "btrl %1,%0"
>  :"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
>}
># 117 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void __clear_bit_unlock(unsigned long nr, volatile unsigned long *addr)
>{
> __asm__ __volatile__("": : :"memory");
> __clear_bit(nr, addr);
>}
># 135 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void __change_bit(int nr, volatile unsigned long * addr)
>{
> __asm__ __volatile__(
>  "btcl %1,%0"
>  :"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
>}
># 153 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) void change_bit(int nr, volatile unsigned long * addr)
>{
> __asm__ __volatile__( ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; "
>  "btcl %1,%0"
>  :"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
>}
># 170 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int test_and_set_bit(int nr, volatile unsigned long * addr)
>{
> int oldbit;
>
> __asm__ __volatile__( ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; "
>  "btsl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit),"+m" ((*(volatile long *) addr))
>  :"Ir" (nr) : "memory");
> return oldbit;
>}
># 188 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int test_and_set_bit_lock(int nr, volatile unsigned long *addr)
>{
> return test_and_set_bit(nr, addr);
>}
># 202 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile unsigned long * addr)
>{
> int oldbit;
>
> __asm__(
>  "btsl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit),"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
> return oldbit;
>}
># 222 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile unsigned long * addr)
>{
> int oldbit;
>
> __asm__ __volatile__( ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; "
>  "btrl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit),"+m" ((*(volatile long *) addr))
>  :"Ir" (nr) : "memory");
> return oldbit;
>}
># 242 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile unsigned long *addr)
>{
> int oldbit;
>
> __asm__(
>  "btrl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit),"+m" ((*(volatile long *) addr))
>  :"Ir" (nr));
> return oldbit;
>}
>
>
>static inline __attribute__((always_inline)) int __test_and_change_bit(int nr, volatile unsigned long *addr)
>{
> int oldbit;
>
> __asm__ __volatile__(
>  "btcl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit),"+m" ((*(volatile long *) addr))
>  :"Ir" (nr) : "memory");
> return oldbit;
>}
># 273 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int test_and_change_bit(int nr, volatile unsigned long* addr)
>{
> int oldbit;
>
> __asm__ __volatile__( ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; "
>  "btcl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit),"+m" ((*(volatile long *) addr))
>  :"Ir" (nr) : "memory");
> return oldbit;
>}
># 293 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) int constant_test_bit(int nr, const volatile unsigned long *addr)
>{
> return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
>}
>
>static inline __attribute__((always_inline)) int variable_test_bit(int nr, const volatile unsigned long * addr)
>{
> int oldbit;
>
> __asm__ __volatile__(
>  "btl %2,%1\n\tsbbl %0,%0"
>  :"=r" (oldbit)
>  :"m" ((*(volatile long *) addr)),"Ir" (nr));
> return oldbit;
>}
># 324 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int find_first_zero_bit(const unsigned long *addr, unsigned size)
>{
> int d0, d1, d2;
> int res;
>
> if (!size)
>  return 0;
>
> __asm__ __volatile__(
>  "movl $-1,%%eax\n\t"
>  "xorl %%edx,%%edx\n\t"
>  "repe; scasl\n\t"
>  "je 1f\n\t"
>  "xorl -4(%%edi),%%eax\n\t"
>  "subl $4,%%edi\n\t"
>  "bsfl %%eax,%%edx\n"
>  "1:\tsubl %%ebx,%%edi\n\t"
>  "shll $3,%%edi\n\t"
>  "addl %%edi,%%edx"
>  :"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
>  :"1" ((size + 31) >> 5), "2" (addr), "b" (addr) : "memory");
> return res;
>}
>
>
>
>
>
>
>
>int find_next_zero_bit(const unsigned long *addr, int size, int offset);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long __ffs(unsigned long word)
>{
> __asm__("bsfl %1,%0"
>  :"=r" (word)
>  :"rm" (word));
> return word;
>}
># 378 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) unsigned find_first_bit(const unsigned long *addr, unsigned size)
>{
> unsigned x = 0;
>
> while (x < size) {
>  unsigned long val = *addr++;
>  if (val)
>   return __ffs(val) + x;
>  x += (sizeof(*addr)<<3);
> }
> return x;
>}
>
>
>
>
>
>
>
>int find_next_bit(const unsigned long *addr, int size, int offset);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long ffz(unsigned long word)
>{
> __asm__("bsfl %1,%0"
>  :"=r" (word)
>  :"r" (~word));
> return word;
>}
>
>
>
># 1 "include/asm-generic/bitops/sched.h" 1
># 12 "include/asm-generic/bitops/sched.h"
>static inline __attribute__((always_inline)) int sched_find_first_bit(const unsigned long *b)
>{
>
>
>
>
>
> if (b[0])
>  return __ffs(b[0]);
> if (b[1])
>  return __ffs(b[1]) + 32;
> if (b[2])
>  return __ffs(b[2]) + 64;
> return __ffs(b[3]) + 96;
>
>
>
>}
># 416 "include/asm/bitops_32.h" 2
># 425 "include/asm/bitops_32.h"
>static inline __attribute__((always_inline)) int ffs(int x)
>{
> int r;
>
> __asm__("bsfl %1,%0\n\t"
>  "jnz 1f\n\t"
>  "movl $-1,%0\n"
>  "1:" : "=r" (r) : "rm" (x));
> return r+1;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int fls(int x)
>{
> int r;
>
> __asm__("bsrl %1,%0\n\t"
>  "jnz 1f\n\t"
>  "movl $-1,%0\n"
>  "1:" : "=r" (r) : "rm" (x));
> return r+1;
>}
>
># 1 "include/asm-generic/bitops/hweight.h" 1
>
>
>
>
>
>extern unsigned int hweight32(unsigned int w);
>extern unsigned int hweight16(unsigned int w);
>extern unsigned int hweight8(unsigned int w);
>extern unsigned long hweight64(__u64 w);
># 454 "include/asm/bitops_32.h" 2
>
>
>
># 1 "include/asm-generic/bitops/fls64.h" 1
>
>
>
>
>
>static inline __attribute__((always_inline)) int fls64(__u64 x)
>{
> __u32 h = x >> 32;
> if (h)
>  return fls(h) + 32;
> return fls(x);
>}
># 458 "include/asm/bitops_32.h" 2
>
>
>
># 1 "include/asm-generic/bitops/ext2-non-atomic.h" 1
>
>
>
># 1 "include/asm-generic/bitops/le.h" 1
>
>
>
>
># 1 "include/asm/byteorder.h" 1
># 11 "include/asm/byteorder.h"
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swab32(__u32 x)
>{
>
> __asm__("bswap %0" : "=r" (x) : "0" (x));
>
>
>
>
>
>
>
> return x;
>}
>
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 ___arch__swab64(__u64 val)
>{
> union {
>  struct { __u32 a,b; } s;
>  __u64 u;
> } v;
> v.u = val;
>
> asm("bswapl %0 ; bswapl %1 ; xchgl %0,%1"
>     : "=r" (v.s.a), "=r" (v.s.b)
>     : "0" (v.s.a), "1" (v.s.b));
>
>
>
>
>
> return v.u;
>}
># 70 "include/asm/byteorder.h"
># 1 "include/linux/byteorder/little_endian.h" 1
># 12 "include/linux/byteorder/little_endian.h"
># 1 "include/linux/byteorder/swab.h" 1
># 64 "include/linux/byteorder/swab.h"
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 ___swab16(__u16 x)
>{
> return x<<8 | x>>8;
>}
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___swab32(__u32 x)
>{
> return x<<24 | x>>24 |
>  (x & (__u32)0x0000ff00UL)<<8 |
>  (x & (__u32)0x00ff0000UL)>>8;
>}
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 ___swab64(__u64 x)
>{
> return x<<56 | x>>56 |
>  (x & (__u64)0x000000000000ff00ULL)<<40 |
>  (x & (__u64)0x0000000000ff0000ULL)<<24 |
>  (x & (__u64)0x00000000ff000000ULL)<< 8 |
>         (x & (__u64)0x000000ff00000000ULL)>> 8 |
>  (x & (__u64)0x0000ff0000000000ULL)>>24 |
>  (x & (__u64)0x00ff000000000000ULL)>>40;
>}
># 163 "include/linux/byteorder/swab.h"
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 x)
>{
> return ___swab16(x);
>}
>static __inline__ __attribute__((always_inline)) __u16 __swab16p(const __u16 *x)
>{
> return ___swab16(*(x));
>}
>static __inline__ __attribute__((always_inline)) void __swab16s(__u16 *addr)
>{
> ((void)(*(addr) = ___swab16(*(addr))));
>}
>
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswab32(__u32 x)
>{
> return ___arch__swab32(x);
>}
>static __inline__ __attribute__((always_inline)) __u32 __swab32p(const __u32 *x)
>{
> return ___arch__swab32(*(x));
>}
>static __inline__ __attribute__((always_inline)) void __swab32s(__u32 *addr)
>{
> ((void)(*(addr) = ___arch__swab32(*(addr))));
>}
>
>
>static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 __fswab64(__u64 x)
>{
>
>
>
>
>
> return ___arch__swab64(x);
>
>}
>static __inline__ __attribute__((always_inline)) __u64 __swab64p(const __u64 *x)
>{
> return ___arch__swab64(*(x));
>}
>static __inline__ __attribute__((always_inline)) void __swab64s(__u64 *addr)
>{
> ((void)(*(addr) = ___arch__swab64(*(addr))));
>}
># 13 "include/linux/byteorder/little_endian.h" 2
># 43 "include/linux/byteorder/little_endian.h"
>static inline __attribute__((always_inline)) __le64 __cpu_to_le64p(const __u64 *p)
>{
> return ( __le64)*p;
>}
>static inline __attribute__((always_inline)) __u64 __le64_to_cpup(const __le64 *p)
>{
> return ( __u64)*p;
>}
>static inline __attribute__((always_inline)) __le32 __cpu_to_le32p(const __u32 *p)
>{
> return ( __le32)*p;
>}
>static inline __attribute__((always_inline)) __u32 __le32_to_cpup(const __le32 *p)
>{
> return ( __u32)*p;
>}
>static inline __attribute__((always_inline)) __le16 __cpu_to_le16p(const __u16 *p)
>{
> return ( __le16)*p;
>}
>static inline __attribute__((always_inline)) __u16 __le16_to_cpup(const __le16 *p)
>{
> return ( __u16)*p;
>}
>static inline __attribute__((always_inline)) __be64 __cpu_to_be64p(const __u64 *p)
>{
> return ( __be64)__swab64p(p);
>}
>static inline __attribute__((always_inline)) __u64 __be64_to_cpup(const __be64 *p)
>{
> return __swab64p((__u64 *)p);
>}
>static inline __attribute__((always_inline)) __be32 __cpu_to_be32p(const __u32 *p)
>{
> return ( __be32)__swab32p(p);
>}
>static inline __attribute__((always_inline)) __u32 __be32_to_cpup(const __be32 *p)
>{
> return __swab32p((__u32 *)p);
>}
>static inline __attribute__((always_inline)) __be16 __cpu_to_be16p(const __u16 *p)
>{
> return ( __be16)__swab16p(p);
>}
>static inline __attribute__((always_inline)) __u16 __be16_to_cpup(const __be16 *p)
>{
> return __swab16p((__u16 *)p);
>}
># 104 "include/linux/byteorder/little_endian.h"
># 1 "include/linux/byteorder/generic.h" 1
># 105 "include/linux/byteorder/little_endian.h" 2
># 71 "include/asm/byteorder.h" 2
># 6 "include/asm-generic/bitops/le.h" 2
># 5 "include/asm-generic/bitops/ext2-non-atomic.h" 2
># 462 "include/asm/bitops_32.h" 2
>
>
>
>
>
>
># 1 "include/asm-generic/bitops/minix.h" 1
># 469 "include/asm/bitops_32.h" 2
># 3 "include/asm/bitops.h" 2
># 18 "include/linux/bitops.h" 2
>
>
>
>
>
>
>
>static __inline__ __attribute__((always_inline)) int get_bitmask_order(unsigned int count)
>{
> int order;
>
> order = fls(count);
> return order;
>}
>
>static __inline__ __attribute__((always_inline)) int get_count_order(unsigned int count)
>{
> int order;
>
> order = fls(count) - 1;
> if (count & (count - 1))
>  order++;
> return order;
>}
>
>static inline __attribute__((always_inline)) unsigned long hweight_long(unsigned long w)
>{
> return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __u32 rol32(__u32 word, unsigned int shift)
>{
> return (word << shift) | (word >> (32 - shift));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __u32 ror32(__u32 word, unsigned int shift)
>{
> return (word >> shift) | (word << (32 - shift));
>}
>
>static inline __attribute__((always_inline)) unsigned fls_long(unsigned long l)
>{
> if (sizeof(l) == 4)
>  return fls(l);
> return fls64(l);
>}
># 12 "include/asm/cpufeature_32.h" 2
>
># 1 "include/asm/required-features.h" 1
># 14 "include/asm/cpufeature_32.h" 2
># 3 "include/asm/cpufeature.h" 2
># 17 "include/asm/processor_32.h" 2
># 1 "include/asm/msr.h" 1
>
>
>
># 1 "include/asm/msr-index.h" 1
># 5 "include/asm/msr.h" 2
>
>
>
>
>
>
># 1 "include/asm/errno.h" 1
># 1 "include/asm-generic/errno.h" 1
>
>
>
># 1 "include/asm-generic/errno-base.h" 1
># 5 "include/asm-generic/errno.h" 2
># 1 "include/asm/errno.h" 2
># 12 "include/asm/msr.h" 2
>
>static inline __attribute__((always_inline)) unsigned long long native_read_msr(unsigned int msr)
>{
> unsigned long long val;
>
> asm volatile("rdmsr" : "=A" (val) : "c" (msr));
> return val;
>}
>
>static inline __attribute__((always_inline)) unsigned long long native_read_msr_safe(unsigned int msr,
>            int *err)
>{
> unsigned long long val;
>
> asm volatile("2: rdmsr ; xorl %0,%0\n"
>       "1:\n\t"
>       ".section .fixup,\"ax\"\n\t"
>       "3:  movl %3,%0 ; jmp 1b\n\t"
>       ".previous\n\t"
>       ".section __ex_table,\"a\"\n"
>       "   .align 4\n\t"
>       "   .long	2b,3b\n\t"
>       ".previous"
>       : "=r" (*err), "=A" (val)
>       : "c" (msr), "i" (-14));
>
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_msr(unsigned int msr, unsigned long long val)
>{
> asm volatile("wrmsr" : : "c" (msr), "A"(val));
>}
>
>static inline __attribute__((always_inline)) int native_write_msr_safe(unsigned int msr,
>     unsigned long long val)
>{
> int err;
> asm volatile("2: wrmsr ; xorl %0,%0\n"
>       "1:\n\t"
>       ".section .fixup,\"ax\"\n\t"
>       "3:  movl %4,%0 ; jmp 1b\n\t"
>       ".previous\n\t"
>       ".section __ex_table,\"a\"\n"
>       "   .align 4\n\t"
>       "   .long	2b,3b\n\t"
>       ".previous"
>       : "=a" (err)
>       : "c" (msr), "0" ((u32)val), "d" ((u32)(val>>32)),
>         "i" (-14));
> return err;
>}
>
>static inline __attribute__((always_inline)) unsigned long long native_read_tsc(void)
>{
> unsigned long long val;
> asm volatile("rdtsc" : "=A" (val));
> return val;
>}
>
>static inline __attribute__((always_inline)) unsigned long long native_read_pmc(void)
>{
> unsigned long long val;
> asm volatile("rdpmc" : "=A" (val));
> return val;
>}
>
>
>
>
># 1 "include/linux/errno.h" 1
>
>
>
># 1 "include/asm/errno.h" 1
># 5 "include/linux/errno.h" 2
># 83 "include/asm/msr.h" 2
># 96 "include/asm/msr.h"
>static inline __attribute__((always_inline)) void wrmsr(u32 __msr, u32 __low, u32 __high)
>{
> native_write_msr(__msr, ((u64)__high << 32) | __low);
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int wrmsr_safe(u32 __msr, u32 __low, u32 __high)
>{
> return native_write_msr_safe(__msr, ((u64)__high << 32) | __low);
>}
># 139 "include/asm/msr.h"
>void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
>void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
>int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
>int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
># 18 "include/asm/processor_32.h" 2
># 1 "include/asm/system.h" 1
>
># 1 "include/asm/system_32.h" 1
>
>
>
># 1 "include/linux/kernel.h" 1
># 10 "include/linux/kernel.h"
># 1 "/usr/lib/gcc/i386-redhat-linux/4.1.2/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/i386-redhat-linux/4.1.2/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 105 "/usr/lib/gcc/i386-redhat-linux/4.1.2/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 11 "include/linux/kernel.h" 2
># 1 "include/linux/linkage.h" 1
>
>
>
># 1 "include/asm/linkage.h" 1
>
># 1 "include/asm/linkage_32.h" 1
># 3 "include/asm/linkage.h" 2
># 5 "include/linux/linkage.h" 2
># 12 "include/linux/kernel.h" 2
>
>
>
>
># 1 "include/linux/log2.h" 1
># 21 "include/linux/log2.h"
>extern __attribute__((const, noreturn))
>int ____ilog2_NaN(void);
># 31 "include/linux/log2.h"
>static inline __attribute__((always_inline)) __attribute__((const))
>int __ilog2_u32(u32 n)
>{
> return fls(n) - 1;
>}
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>int __ilog2_u64(u64 n)
>{
> return fls64(n) - 1;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>bool is_power_of_2(unsigned long n)
>{
> return (n != 0 && ((n & (n - 1)) == 0));
>}
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>unsigned long __roundup_pow_of_two(unsigned long n)
>{
> return 1UL << fls_long(n - 1);
>}
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((const))
>unsigned long __rounddown_pow_of_two(unsigned long n)
>{
> return 1UL << (fls_long(n) - 1);
>}
># 17 "include/linux/kernel.h" 2
>
># 1 "include/asm/bug.h" 1
># 36 "include/asm/bug.h"
>void out_of_line_bug(void);
>
>
>
>
># 1 "include/asm-generic/bug.h" 1
># 10 "include/asm-generic/bug.h"
>struct bug_entry {
> unsigned long bug_addr;
>
> const char *file;
> unsigned short line;
>
> unsigned short flags;
>};
># 42 "include/asm/bug.h" 2
># 19 "include/linux/kernel.h" 2
>
>extern const char linux_banner[];
>extern const char linux_proc_banner[];
># 47 "include/linux/kernel.h"
># 1 "include/asm/div64.h" 1
># 42 "include/asm/div64.h"
>static inline __attribute__((always_inline)) long
>div_ll_X_l_rem(long long divs, long div, long *rem)
>{
> long dum2;
>      __asm__("divl %2":"=a"(dum2), "=d"(*rem)
>      : "rm"(div), "A"(divs));
>
> return dum2;
>
>}
>
>extern uint64_t div64_64(uint64_t dividend, uint64_t divisor);
># 48 "include/linux/kernel.h" 2
># 86 "include/linux/kernel.h"
>extern int console_printk[];
>
>
>
>
>
>
>struct completion;
>struct pt_regs;
>struct user;
># 108 "include/linux/kernel.h"
>extern int cond_resched(void);
># 129 "include/linux/kernel.h"
>extern struct atomic_notifier_head panic_notifier_list;
>extern long (*panic_blink)(long time);
> void panic(const char * fmt, ...)
> __attribute__ ((noreturn, format (printf, 1, 2))) ;
>extern void oops_enter(void);
>extern void oops_exit(void);
>extern int oops_may_print(void);
>__attribute__((regparm(3))) void do_exit(long error_code)
> __attribute__((noreturn));
> void complete_and_exit(struct completion *, long)
> __attribute__((noreturn));
>extern unsigned long simple_strtoul(const char *,char **,unsigned int);
>extern long simple_strtol(const char *,char **,unsigned int);
>extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
>extern long long simple_strtoll(const char *,char **,unsigned int);
>extern int sprintf(char * buf, const char * fmt, ...)
> __attribute__ ((format (printf, 2, 3)));
>extern int vsprintf(char *buf, const char *, va_list)
> __attribute__ ((format (printf, 2, 0)));
>extern int snprintf(char * buf, size_t size, const char * fmt, ...)
> __attribute__ ((format (printf, 3, 4)));
>extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
> __attribute__ ((format (printf, 3, 0)));
>extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
> __attribute__ ((format (printf, 3, 4)));
>extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
> __attribute__ ((format (printf, 3, 0)));
>extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
> __attribute__ ((format (printf, 2, 3)));
>extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
>
>extern int sscanf(const char *, const char *, ...)
> __attribute__ ((format (scanf, 2, 3)));
>extern int vsscanf(const char *, const char *, va_list)
> __attribute__ ((format (scanf, 2, 0)));
>
>extern int get_option(char **str, int *pint);
>extern char *get_options(const char *str, int nints, int *ints);
>extern unsigned long long memparse(char *ptr, char **retptr);
>
>extern int core_kernel_text(unsigned long addr);
>extern int __kernel_text_address(unsigned long addr);
>extern int kernel_text_address(unsigned long addr);
>struct pid;
>extern struct pid *session_of_pgrp(struct pid *pgrp);
>
>extern void dump_thread(struct pt_regs *regs, struct user *dump);
>
>
> __attribute__((regparm(0))) int vprintk(const char *fmt, va_list args)
> __attribute__ ((format (printf, 1, 0)));
> __attribute__((regparm(0))) int printk(const char * fmt, ...)
> __attribute__ ((format (printf, 1, 2))) ;
>extern int log_buf_get_len(void);
>extern int log_buf_read(int idx);
>extern int log_buf_copy(char *dest, int idx, int len);
># 197 "include/linux/kernel.h"
>unsigned long int_sqrt(unsigned long);
>
>extern int printk_ratelimit(void);
>extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);
>extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
>    unsigned int interval_msec);
>
>static inline __attribute__((always_inline)) void console_silent(void)
>{
> (console_printk[0]) = 0;
>}
>
>static inline __attribute__((always_inline)) void console_verbose(void)
>{
> if ((console_printk[0]))
>  (console_printk[0]) = 15;
>}
>
>extern void bust_spinlocks(int yes);
>extern void wake_up_klogd(void);
>extern int oops_in_progress;
>extern int panic_timeout;
>extern int panic_on_oops;
>extern int panic_on_unrecovered_nmi;
>extern int tainted;
>extern const char *print_tainted(void);
>extern void add_taint(unsigned);
>
>
>extern enum system_states {
> SYSTEM_BOOTING,
> SYSTEM_RUNNING,
> SYSTEM_HALT,
> SYSTEM_POWER_OFF,
> SYSTEM_RESTART,
> SYSTEM_SUSPEND_DISK,
>} system_state;
># 244 "include/linux/kernel.h"
>extern void dump_stack(void) ;
>
>enum {
> DUMP_PREFIX_NONE,
> DUMP_PREFIX_ADDRESS,
> DUMP_PREFIX_OFFSET
>};
>extern void hex_dump_to_buffer(const void *buf, size_t len,
>    int rowsize, int groupsize,
>    char *linebuf, size_t linebuflen, bool ascii);
>extern void print_hex_dump(const char *level, const char *prefix_str,
>    int prefix_type, int rowsize, int groupsize,
>    const void *buf, size_t len, bool ascii);
>extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
>   const void *buf, size_t len);
># 281 "include/linux/kernel.h"
>static inline __attribute__((always_inline)) int __attribute__ ((format (printf, 1, 2))) pr_debug(const char * fmt, ...)
>{
> return 0;
>}
># 382 "include/linux/kernel.h"
>struct sysinfo;
>extern int do_sysinfo(struct sysinfo *info);
>
>
>
>
>struct sysinfo {
> long uptime;
> unsigned long loads[3];
> unsigned long totalram;
> unsigned long freeram;
> unsigned long sharedram;
> unsigned long bufferram;
> unsigned long totalswap;
> unsigned long freeswap;
> unsigned short procs;
> unsigned short pad;
> unsigned long totalhigh;
> unsigned long freehigh;
> unsigned int mem_unit;
> char _f[20-2*sizeof(long)-sizeof(int)];
>};
># 5 "include/asm/system_32.h" 2
># 1 "include/asm/segment.h" 1
># 6 "include/asm/system_32.h" 2
># 1 "include/asm/cpufeature.h" 1
># 7 "include/asm/system_32.h" 2
># 1 "include/asm/cmpxchg.h" 1
>
># 1 "include/asm/cmpxchg_32.h" 1
># 13 "include/asm/cmpxchg_32.h"
>struct __xchg_dummy { unsigned long a[100]; };
># 30 "include/asm/cmpxchg_32.h"
>static inline __attribute__((always_inline)) void __set_64bit (unsigned long long * ptr,
>  unsigned int low, unsigned int high)
>{
> __asm__ __volatile__ (
>  "\n1:\t"
>  "movl (%0), %%eax\n\t"
>  "movl 4(%0), %%edx\n\t"
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "cmpxchg8b (%0)\n\t"
>  "jnz 1b"
>  :
>  : "D"(ptr),
>   "b"(low),
>   "c"(high)
>  : "ax","dx","memory");
>}
>
>static inline __attribute__((always_inline)) void __set_64bit_constant (unsigned long long *ptr,
>       unsigned long long value)
>{
> __set_64bit(ptr,(unsigned int)(value), (unsigned int)((value)>>32ULL));
>}
>
>
>
>static inline __attribute__((always_inline)) void __set_64bit_var (unsigned long long *ptr,
>    unsigned long long value)
>{
> __set_64bit(ptr,*(((unsigned int*)&(value))+0), *(((unsigned int*)&(value))+1));
>}
># 75 "include/asm/cmpxchg_32.h"
>static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
>{
> switch (size) {
>  case 1:
>   __asm__ __volatile__("xchgb %b0,%1"
>    :"=q" (x)
>    :"m" (*((struct __xchg_dummy *)(ptr))), "0" (x)
>    :"memory");
>   break;
>  case 2:
>   __asm__ __volatile__("xchgw %w0,%1"
>    :"=r" (x)
>    :"m" (*((struct __xchg_dummy *)(ptr))), "0" (x)
>    :"memory");
>   break;
>  case 4:
>   __asm__ __volatile__("xchgl %0,%1"
>    :"=r" (x)
>    :"m" (*((struct __xchg_dummy *)(ptr))), "0" (x)
>    :"memory");
>   break;
> }
> return x;
>}
># 119 "include/asm/cmpxchg_32.h"
>static inline __attribute__((always_inline)) unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
>          unsigned long new, int size)
>{
> unsigned long prev;
> switch (size) {
> case 1:
>  __asm__ __volatile__(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "cmpxchgb %b1,%2"
>         : "=a"(prev)
>         : "q"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> case 2:
>  __asm__ __volatile__(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "cmpxchgw %w1,%2"
>         : "=a"(prev)
>         : "r"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> case 4:
>  __asm__ __volatile__(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "cmpxchgl %1,%2"
>         : "=a"(prev)
>         : "r"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> }
> return old;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long __sync_cmpxchg(volatile void *ptr,
>         unsigned long old,
>         unsigned long new, int size)
>{
> unsigned long prev;
> switch (size) {
> case 1:
>  __asm__ __volatile__("lock; cmpxchgb %b1,%2"
>         : "=a"(prev)
>         : "q"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> case 2:
>  __asm__ __volatile__("lock; cmpxchgw %w1,%2"
>         : "=a"(prev)
>         : "r"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> case 4:
>  __asm__ __volatile__("lock; cmpxchgl %1,%2"
>         : "=a"(prev)
>         : "r"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> }
> return old;
>}
>
>static inline __attribute__((always_inline)) unsigned long __cmpxchg_local(volatile void *ptr,
>   unsigned long old, unsigned long new, int size)
>{
> unsigned long prev;
> switch (size) {
> case 1:
>  __asm__ __volatile__("cmpxchgb %b1,%2"
>         : "=a"(prev)
>         : "q"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> case 2:
>  __asm__ __volatile__("cmpxchgw %w1,%2"
>         : "=a"(prev)
>         : "r"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> case 4:
>  __asm__ __volatile__("cmpxchgl %1,%2"
>         : "=a"(prev)
>         : "r"(new), "m"(*((struct __xchg_dummy *)(ptr))), "0"(old)
>         : "memory");
>  return prev;
> }
> return old;
>}
># 255 "include/asm/cmpxchg_32.h"
>static inline __attribute__((always_inline)) unsigned long long __cmpxchg64(volatile void *ptr, unsigned long long old,
>          unsigned long long new)
>{
> unsigned long long prev;
> __asm__ __volatile__(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "cmpxchg8b %3"
>        : "=A"(prev)
>        : "b"((unsigned long)new),
>          "c"((unsigned long)(new >> 32)),
>          "m"(*((struct __xchg_dummy *)(ptr))),
>          "0"(old)
>        : "memory");
> return prev;
>}
>
>static inline __attribute__((always_inline)) unsigned long long __cmpxchg64_local(volatile void *ptr,
>   unsigned long long old, unsigned long long new)
>{
> unsigned long long prev;
> __asm__ __volatile__("cmpxchg8b %3"
>        : "=A"(prev)
>        : "b"((unsigned long)new),
>          "c"((unsigned long)(new >> 32)),
>          "m"(*((struct __xchg_dummy *)(ptr))),
>          "0"(old)
>        : "memory");
> return prev;
>}
># 3 "include/asm/cmpxchg.h" 2
># 8 "include/asm/system_32.h" 2
>
>
>
>
>struct task_struct;
>extern struct task_struct * __switch_to(struct task_struct *prev, struct task_struct *next) __attribute__((regparm(3)));
># 93 "include/asm/system_32.h"
>static inline __attribute__((always_inline)) void native_clts(void)
>{
> asm volatile ("clts");
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr0(void)
>{
> unsigned long val;
> asm volatile("movl %%cr0,%0\n\t" :"=r" (val));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr0(unsigned long val)
>{
> asm volatile("movl %0,%%cr0": :"r" (val));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr2(void)
>{
> unsigned long val;
> asm volatile("movl %%cr2,%0\n\t" :"=r" (val));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr2(unsigned long val)
>{
> asm volatile("movl %0,%%cr2": :"r" (val));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr3(void)
>{
> unsigned long val;
> asm volatile("movl %%cr3,%0\n\t" :"=r" (val));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr3(unsigned long val)
>{
> asm volatile("movl %0,%%cr3": :"r" (val));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr4(void)
>{
> unsigned long val;
> asm volatile("movl %%cr4,%0\n\t" :"=r" (val));
> return val;
>}
>
>static inline __attribute__((always_inline)) unsigned long native_read_cr4_safe(void)
>{
> unsigned long val;
>
> asm volatile("1: movl %%cr4, %0		\n"
>  "2:				\n"
>  ".section __ex_table,\"a\"	\n"
>  ".long 1b,2b			\n"
>  ".previous			\n"
>  : "=r" (val): "0" (0));
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_write_cr4(unsigned long val)
>{
> asm volatile("movl %0,%%cr4": :"r" (val));
>}
>
>static inline __attribute__((always_inline)) void native_wbinvd(void)
>{
> asm volatile("wbinvd": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void clflush(volatile void *__p)
>{
> asm volatile("clflush %0" : "+m" (*(char *)__p));
>}
># 193 "include/asm/system_32.h"
>static inline __attribute__((always_inline)) unsigned long get_limit(unsigned long segment)
>{
> unsigned long __limit;
> __asm__("lsll %1,%0"
>  :"=r" (__limit):"r" (segment));
> return __limit+1;
>}
># 302 "include/asm/system_32.h"
># 1 "include/linux/irqflags.h" 1
># 46 "include/linux/irqflags.h"
># 1 "include/asm/irqflags.h" 1
>
># 1 "include/asm/irqflags_32.h" 1
># 12 "include/asm/irqflags_32.h"
># 1 "include/asm/processor-flags.h" 1
># 13 "include/asm/irqflags_32.h" 2
>
>
>static inline __attribute__((always_inline)) unsigned long native_save_fl(void)
>{
> unsigned long f;
> asm volatile("pushfl ; popl %0":"=g" (f): );
> return f;
>}
>
>static inline __attribute__((always_inline)) void native_restore_fl(unsigned long f)
>{
> asm volatile("pushl %0 ; popfl":
>        :"g" (f)
>        :"memory", "cc");
>}
>
>static inline __attribute__((always_inline)) void native_irq_disable(void)
>{
> asm volatile("cli": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void native_irq_enable(void)
>{
> asm volatile("sti": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void native_safe_halt(void)
>{
> asm volatile("sti; hlt": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void native_halt(void)
>{
> asm volatile("hlt": : :"memory");
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long __raw_local_save_flags(void)
>{
> return native_save_fl();
>}
>
>static inline __attribute__((always_inline)) void raw_local_irq_restore(unsigned long flags)
>{
> native_restore_fl(flags);
>}
>
>static inline __attribute__((always_inline)) void raw_local_irq_disable(void)
>{
> native_irq_disable();
>}
>
>static inline __attribute__((always_inline)) void raw_local_irq_enable(void)
>{
> native_irq_enable();
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void raw_safe_halt(void)
>{
> native_safe_halt();
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void halt(void)
>{
> native_halt();
>}
>
>
>
>
>static inline __attribute__((always_inline)) unsigned long __raw_local_irq_save(void)
>{
> unsigned long flags = __raw_local_save_flags();
>
> raw_local_irq_disable();
>
> return flags;
>}
># 121 "include/asm/irqflags_32.h"
>static inline __attribute__((always_inline)) int raw_irqs_disabled_flags(unsigned long flags)
>{
> return !(flags & 0x00000200);
>}
>
>static inline __attribute__((always_inline)) int raw_irqs_disabled(void)
>{
> unsigned long flags = __raw_local_save_flags();
>
> return raw_irqs_disabled_flags(flags);
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void trace_hardirqs_fixup_flags(unsigned long flags)
>{
> if (raw_irqs_disabled_flags(flags))
>  do { } while (0);
> else
>  do { } while (0);
>}
>
>static inline __attribute__((always_inline)) void trace_hardirqs_fixup(void)
>{
> unsigned long flags = __raw_local_save_flags();
>
> trace_hardirqs_fixup_flags(flags);
>}
># 3 "include/asm/irqflags.h" 2
># 47 "include/linux/irqflags.h" 2
># 303 "include/asm/system_32.h" 2
>
>
>
>
>
>void disable_hlt(void);
>void enable_hlt(void);
>
>extern int es7000_plat;
>void cpu_idle_wait(void);
>
>extern unsigned long arch_align_stack(unsigned long sp);
>extern void free_init_pages(char *what, unsigned long begin, unsigned long end);
>
>void default_idle(void);
>void __show_registers(struct pt_regs *, int all);
># 3 "include/asm/system.h" 2
># 19 "include/asm/processor_32.h" 2
># 1 "include/linux/cache.h" 1
>
>
>
>
># 1 "include/asm/cache.h" 1
># 6 "include/linux/cache.h" 2
># 20 "include/asm/processor_32.h" 2
># 1 "include/linux/threads.h" 1
># 21 "include/asm/processor_32.h" 2
># 1 "include/asm/percpu.h" 1
>
># 1 "include/asm/percpu_32.h" 1
># 48 "include/asm/percpu_32.h"
>extern unsigned long __per_cpu_offset[];
># 63 "include/asm/percpu_32.h"
>extern __typeof__(unsigned long) per_cpu__this_cpu_off;
># 98 "include/asm/percpu_32.h"
>extern void __bad_percpu_size(void);
># 3 "include/asm/percpu.h" 2
># 22 "include/asm/processor_32.h" 2
># 1 "include/linux/cpumask.h" 1
># 86 "include/linux/cpumask.h"
># 1 "include/linux/bitmap.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/string.h" 1
># 14 "include/linux/string.h"
>extern char *strndup_user(const char *, long);
>
>
>
>
># 1 "include/asm/string.h" 1
>
># 1 "include/asm/string_32.h" 1
># 9 "include/asm/string_32.h"
>extern char *strcpy(char *dest, const char *src);
>
>
>extern char *strncpy(char *dest, const char *src, size_t count);
>
>
>extern char *strcat(char *dest, const char *src);
>
>
>extern char *strncat(char *dest, const char *src, size_t count);
>
>
>extern int strcmp(const char *cs, const char *ct);
>
>
>extern int strncmp(const char *cs, const char *ct, size_t count);
>
>
>extern char *strchr(const char *s, int c);
>
>
>extern size_t strlen(const char *s);
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) void * __memcpy(void * to, const void * from, size_t n)
>{
>int d0, d1, d2;
>__asm__ __volatile__(
> "rep ; movsl\n\t"
> "movl %4,%%ecx\n\t"
> "andl $3,%%ecx\n\t"
> "jz 1f\n\t"
> "rep ; movsb\n\t"
> "1:"
> : "=&c" (d0), "=&D" (d1), "=&S" (d2)
> : "0" (n/4), "g" (n), "1" ((long) to), "2" ((long) from)
> : "memory");
>return (to);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) void * __constant_memcpy(void * to, const void * from, size_t n)
>{
> long esi, edi;
> if (!n) return to;
>
> switch (n) {
>  case 1: *(char*)to = *(char*)from; return to;
>  case 2: *(short*)to = *(short*)from; return to;
>  case 4: *(int*)to = *(int*)from; return to;
>
>  case 3: *(short*)to = *(short*)from;
>   *((char*)to+2) = *((char*)from+2); return to;
>  case 5: *(int*)to = *(int*)from;
>   *((char*)to+4) = *((char*)from+4); return to;
>  case 6: *(int*)to = *(int*)from;
>   *((short*)to+2) = *((short*)from+2); return to;
>  case 8: *(int*)to = *(int*)from;
>   *((int*)to+1) = *((int*)from+1); return to;
>
> }
>
> esi = (long) from;
> edi = (long) to;
> if (n >= 5*4) {
>
>  int ecx;
>  __asm__ __volatile__(
>   "rep ; movsl"
>   : "=&c" (ecx), "=&D" (edi), "=&S" (esi)
>   : "0" (n/4), "1" (edi),"2" (esi)
>   : "memory"
>  );
> } else {
>
>  if (n >= 4*4) __asm__ __volatile__("movsl"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
>  if (n >= 3*4) __asm__ __volatile__("movsl"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
>  if (n >= 2*4) __asm__ __volatile__("movsl"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
>  if (n >= 1*4) __asm__ __volatile__("movsl"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
> }
> switch (n % 4) {
>
>  case 0: return to;
>  case 1: __asm__ __volatile__("movsb"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
>   return to;
>  case 2: __asm__ __volatile__("movsw"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
>   return to;
>  default: __asm__ __volatile__("movsw\n\tmovsb"
>   :"=&D"(edi),"=&S"(esi):"0"(edi),"1"(esi):"memory");
>   return to;
> }
>}
># 153 "include/asm/string_32.h"
>void *memmove(void * dest,const void * src, size_t n);
>
>
>
>
>extern void *memchr(const void * cs,int c,size_t count);
>
>static inline __attribute__((always_inline)) void * __memset_generic(void * s, char c,size_t count)
>{
>int d0, d1;
>__asm__ __volatile__(
> "rep\n\t"
> "stosb"
> : "=&c" (d0), "=&D" (d1)
> :"a" (c),"1" (s),"0" (count)
> :"memory");
>return s;
>}
># 180 "include/asm/string_32.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) void * __constant_c_memset(void * s, unsigned long c, size_t count)
>{
>int d0, d1;
>__asm__ __volatile__(
> "rep ; stosl\n\t"
> "testb $2,%b3\n\t"
> "je 1f\n\t"
> "stosw\n"
> "1:\ttestb $1,%b3\n\t"
> "je 2f\n\t"
> "stosb\n"
> "2:"
> :"=&c" (d0), "=&D" (d1)
> :"a" (c), "q" (count), "0" (count/4), "1" ((long) s)
> :"memory");
>return (s);
>}
>
>
>
>extern size_t strnlen(const char * s, size_t count);
>
>
>
>extern char *strstr(const char *cs, const char *ct);
>
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
>{
> switch (count) {
>  case 0:
>   return s;
>  case 1:
>   *(unsigned char *)s = pattern;
>   return s;
>  case 2:
>   *(unsigned short *)s = pattern;
>   return s;
>  case 3:
>   *(unsigned short *)s = pattern;
>   *(2+(unsigned char *)s) = pattern;
>   return s;
>  case 4:
>   *(unsigned long *)s = pattern;
>   return s;
> }
>
>
>
>
>
>
>
>{
> int d0, d1;
> switch (count % 4) {
>  case 0: __asm__ __volatile__( "rep ; stosl" "" : "=&c" (d0), "=&D" (d1) : "a" (pattern),"0" (count/4),"1" ((long) s) : "memory"); return s;
>  case 1: __asm__ __volatile__( "rep ; stosl" "\n\tstosb" : "=&c" (d0), "=&D" (d1) : "a" (pattern),"0" (count/4),"1" ((long) s) : "memory"); return s;
>  case 2: __asm__ __volatile__( "rep ; stosl" "\n\tstosw" : "=&c" (d0), "=&D" (d1) : "a" (pattern),"0" (count/4),"1" ((long) s) : "memory"); return s;
>  default: __asm__ __volatile__( "rep ; stosl" "\n\tstosw\n\tstosb" : "=&c" (d0), "=&D" (d1) : "a" (pattern),"0" (count/4),"1" ((long) s) : "memory"); return s;
> }
>}
>
>
>}
># 269 "include/asm/string_32.h"
>extern void *memscan(void * addr, int c, size_t size);
># 3 "include/asm/string.h" 2
># 20 "include/linux/string.h" 2
># 28 "include/linux/string.h"
>size_t strlcpy(char *, const char *, size_t);
># 37 "include/linux/string.h"
>extern size_t strlcat(char *, const char *, __kernel_size_t);
># 46 "include/linux/string.h"
>extern int strnicmp(const char *, const char *, __kernel_size_t);
>
>
>extern int strcasecmp(const char *s1, const char *s2);
>
>
>extern int strncasecmp(const char *s1, const char *s2, size_t n);
>
>
>
>
>
>extern char * strnchr(const char *, size_t, int);
>
>
>extern char * strrchr(const char *,int);
>
>extern char * strstrip(char *);
># 74 "include/linux/string.h"
>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 *);
># 99 "include/linux/string.h"
>extern int __builtin_memcmp(const void *,const void *,__kernel_size_t);
>
>
>
>
>
>extern char *kstrdup(const char *s, gfp_t gfp);
>extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
>extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
>
>extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
>extern void argv_free(char **argv);
># 9 "include/linux/bitmap.h" 2
># 85 "include/linux/bitmap.h"
>extern int __bitmap_empty(const unsigned long *bitmap, int bits);
>extern int __bitmap_full(const unsigned long *bitmap, int bits);
>extern int __bitmap_equal(const unsigned long *bitmap1,
>                 const unsigned long *bitmap2, int bits);
>extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
>   int bits);
>extern void __bitmap_shift_right(unsigned long *dst,
>                        const unsigned long *src, int shift, int bits);
>extern void __bitmap_shift_left(unsigned long *dst,
>                        const unsigned long *src, int shift, int bits);
>extern void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
>   const unsigned long *bitmap2, int bits);
>extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
>   const unsigned long *bitmap2, int bits);
>extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
>   const unsigned long *bitmap2, int bits);
>extern void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
>   const unsigned long *bitmap2, int bits);
>extern int __bitmap_intersects(const unsigned long *bitmap1,
>   const unsigned long *bitmap2, int bits);
>extern int __bitmap_subset(const unsigned long *bitmap1,
>   const unsigned long *bitmap2, int bits);
>extern int __bitmap_weight(const unsigned long *bitmap, int bits);
>
>extern int bitmap_scnprintf(char *buf, unsigned int len,
>   const unsigned long *src, int nbits);
>extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
>   unsigned long *dst, int nbits);
>extern int bitmap_parse_user(const char *ubuf, unsigned int ulen,
>   unsigned long *dst, int nbits);
>extern int bitmap_scnlistprintf(char *buf, unsigned int len,
>   const unsigned long *src, int nbits);
>extern int bitmap_parselist(const char *buf, unsigned long *maskp,
>   int nmaskbits);
>extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
>  const unsigned long *old, const unsigned long *new, int bits);
>extern int bitmap_bitremap(int oldbit,
>  const unsigned long *old, const unsigned long *new, int bits);
>extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
>extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
>extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void bitmap_zero(unsigned long *dst, int nbits)
>{
> if (nbits <= 32)
>  *dst = 0UL;
> else {
>  int len = (((nbits) + (32) - 1) / (32)) * sizeof(unsigned long);
>  (__builtin_constant_p(0) ? (__builtin_constant_p((len)) ? __constant_c_and_count_memset(((dst)),((0x01010101UL*(unsigned char)(0))),((len))) : __constant_c_memset(((dst)),((0x01010101UL*(unsigned char)(0))),((len)))) : (__builtin_constant_p((len)) ? __memset_generic((((dst))),(((0))),(((len)))) : __memset_generic(((dst)),((0)),((len)))));
> }
>}
>
>static inline __attribute__((always_inline)) void bitmap_fill(unsigned long *dst, int nbits)
>{
> size_t nlongs = (((nbits) + (32) - 1) / (32));
> if (nlongs > 1) {
>  int len = (nlongs - 1) * sizeof(unsigned long);
>  (__builtin_constant_p(0xff) ? (__builtin_constant_p((len)) ? __constant_c_and_count_memset(((dst)),((0x01010101UL*(unsigned char)(0xff))),((len))) : __constant_c_memset(((dst)),((0x01010101UL*(unsigned char)(0xff))),((len)))) : (__builtin_constant_p((len)) ? __memset_generic((((dst))),(((0xff))),(((len)))) : __memset_generic(((dst)),((0xff)),((len)))));
> }
> dst[nlongs - 1] = ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
>}
>
>static inline __attribute__((always_inline)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
>   int nbits)
>{
> if (nbits <= 32)
>  *dst = *src;
> else {
>  int len = (((nbits) + (32) - 1) / (32)) * sizeof(unsigned long);
>  (__builtin_constant_p(len) ? __constant_memcpy((dst),(src),(len)) : __memcpy((dst),(src),(len)));
> }
>}
>
>static inline __attribute__((always_inline)) void bitmap_and(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  *dst = *src1 & *src2;
> else
>  __bitmap_and(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_or(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  *dst = *src1 | *src2;
> else
>  __bitmap_or(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_xor(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  *dst = *src1 ^ *src2;
> else
>  __bitmap_xor(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_andnot(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  *dst = *src1 & ~(*src2);
> else
>  __bitmap_andnot(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
>   int nbits)
>{
> if (nbits <= 32)
>  *dst = ~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
> else
>  __bitmap_complement(dst, src, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_equal(const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  return ! ((*src1 ^ *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
> else
>  return __bitmap_equal(src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_intersects(const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  return ((*src1 & *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL )) != 0;
> else
>  return __bitmap_intersects(src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_subset(const unsigned long *src1,
>   const unsigned long *src2, int nbits)
>{
> if (nbits <= 32)
>  return ! ((*src1 & ~(*src2)) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
> else
>  return __bitmap_subset(src1, src2, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_empty(const unsigned long *src, int nbits)
>{
> if (nbits <= 32)
>  return ! (*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
> else
>  return __bitmap_empty(src, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_full(const unsigned long *src, int nbits)
>{
> if (nbits <= 32)
>  return ! (~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
> else
>  return __bitmap_full(src, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_weight(const unsigned long *src, int nbits)
>{
> if (nbits <= 32)
>  return hweight_long(*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
> return __bitmap_weight(src, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_shift_right(unsigned long *dst,
>   const unsigned long *src, int n, int nbits)
>{
> if (nbits <= 32)
>  *dst = *src >> n;
> else
>  __bitmap_shift_right(dst, src, n, nbits);
>}
>
>static inline __attribute__((always_inline)) void bitmap_shift_left(unsigned long *dst,
>   const unsigned long *src, int n, int nbits)
>{
> if (nbits <= 32)
>  *dst = (*src << n) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
> else
>  __bitmap_shift_left(dst, src, n, nbits);
>}
>
>static inline __attribute__((always_inline)) int bitmap_parse(const char *buf, unsigned int buflen,
>   unsigned long *maskp, int nmaskbits)
>{
> return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
>}
># 87 "include/linux/cpumask.h" 2
>
>typedef struct { unsigned long bits[(((32) + (32) - 1) / (32))]; } cpumask_t;
>extern cpumask_t _unused_cpumask_arg_;
>
>
>static inline __attribute__((always_inline)) void __cpu_set(int cpu, volatile cpumask_t *dstp)
>{
> set_bit(cpu, dstp->bits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpu_clear(int cpu, volatile cpumask_t *dstp)
>{
> clear_bit(cpu, dstp->bits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpus_setall(cpumask_t *dstp, int nbits)
>{
> bitmap_fill(dstp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpus_clear(cpumask_t *dstp, int nbits)
>{
> bitmap_zero(dstp->bits, nbits);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int __cpu_test_and_set(int cpu, cpumask_t *addr)
>{
> return test_and_set_bit(cpu, addr->bits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpus_or(cpumask_t *dstp, const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) void __cpus_complement(cpumask_t *dstp,
>     const cpumask_t *srcp, int nbits)
>{
> bitmap_complement(dstp->bits, srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpus_equal(const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> return bitmap_equal(src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpus_intersects(const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> return bitmap_intersects(src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpus_subset(const cpumask_t *src1p,
>     const cpumask_t *src2p, int nbits)
>{
> return bitmap_subset(src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpus_empty(const cpumask_t *srcp, int nbits)
>{
> return bitmap_empty(srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpus_full(const cpumask_t *srcp, int nbits)
>{
> return bitmap_full(srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpus_weight(const cpumask_t *srcp, int nbits)
>{
> return bitmap_weight(srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __cpus_shift_right(cpumask_t *dstp,
>     const cpumask_t *srcp, int n, int nbits)
>{
> bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __cpus_shift_left(cpumask_t *dstp,
>     const cpumask_t *srcp, int n, int nbits)
>{
> bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
>}
>
>
>int __first_cpu(const cpumask_t *srcp);
>
>int __next_cpu(int n, const cpumask_t *srcp);
># 270 "include/linux/cpumask.h"
>static inline __attribute__((always_inline)) int __cpumask_scnprintf(char *buf, int len,
>     const cpumask_t *srcp, int nbits)
>{
> return bitmap_scnprintf(buf, len, srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __cpumask_parse_user(const char *buf, int len,
>     cpumask_t *dstp, int nbits)
>{
> return bitmap_parse_user(buf, len, dstp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __cpulist_scnprintf(char *buf, int len,
>     const cpumask_t *srcp, int nbits)
>{
> return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __cpulist_parse(const char *buf, cpumask_t *dstp, int nbits)
>{
> return bitmap_parselist(buf, dstp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __cpu_remap(int oldbit,
>  const cpumask_t *oldp, const cpumask_t *newp, int nbits)
>{
> return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
>  const cpumask_t *oldp, const cpumask_t *newp, int nbits)
>{
> bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
>}
># 380 "include/linux/cpumask.h"
>extern cpumask_t cpu_possible_map;
>extern cpumask_t cpu_online_map;
>extern cpumask_t cpu_present_map;
># 401 "include/linux/cpumask.h"
>extern int nr_cpu_ids;
>
>int __any_online_cpu(const cpumask_t *mask);
># 23 "include/asm/processor_32.h" 2
># 1 "include/linux/init.h" 1
># 79 "include/linux/init.h"
>typedef int (*initcall_t)(void);
>typedef void (*exitcall_t)(void);
>
>extern initcall_t __con_initcall_start[], __con_initcall_end[];
>extern initcall_t __security_initcall_start[], __security_initcall_end[];
>
>
>extern char __attribute__ ((__section__ (".init.data"))) boot_command_line[];
>extern char *saved_command_line;
>extern unsigned int reset_devices;
>
>
>void setup_arch(char **);
>void prepare_namespace(void);
># 151 "include/linux/init.h"
>struct obs_kernel_param {
> const char *str;
> int (*setup_func)(char *);
> int early;
>};
># 183 "include/linux/init.h"
>void __attribute__ ((__section__ (".init.text"))) parse_early_param(void);
># 24 "include/asm/processor_32.h" 2
>
>
>
>extern int tsc_disable;
>
>struct desc_struct {
> unsigned long a,b;
>};
># 50 "include/asm/processor_32.h"
>struct cpuinfo_x86 {
> __u8 x86;
> __u8 x86_vendor;
> __u8 x86_model;
> __u8 x86_mask;
> char wp_works_ok;
> char hlt_works_ok;
> char hard_math;
> char rfu;
>        int cpuid_level;
> unsigned long x86_capability[8];
> char x86_vendor_id[16];
> char x86_model_id[64];
> int x86_cache_size;
>
> int x86_cache_alignment;
> char fdiv_bug;
> char f00f_bug;
> char coma_bug;
> char pad0;
> int x86_power;
> unsigned long loops_per_jiffy;
>
> cpumask_t llc_shared_map;
>
> unsigned char x86_max_cores;
> unsigned char apicid;
> unsigned short x86_clflush_size;
>
> unsigned char booted_cores;
> __u8 phys_proc_id;
> __u8 cpu_core_id;
> __u8 cpu_index;
>
>} __attribute__((__aligned__((1 << (7)))));
># 101 "include/asm/processor_32.h"
>extern struct cpuinfo_x86 boot_cpu_data;
>extern struct cpuinfo_x86 new_cpu_data;
>extern struct tss_struct doublefault_tss;
>extern __typeof__(struct tss_struct) per_cpu__init_tss;
>
>
>extern __typeof__(struct cpuinfo_x86) per_cpu__cpu_info;
># 119 "include/asm/processor_32.h"
>extern __typeof__(u8) per_cpu__cpu_llc_id;
>extern char ignore_fpu_irq;
>
>void __attribute__ ((__section__ (".init.text"))) cpu_detect(struct cpuinfo_x86 *c);
>
>extern void identify_boot_cpu(void);
>extern void identify_secondary_cpu(struct cpuinfo_x86 *);
>extern void print_cpu_info(struct cpuinfo_x86 *);
>extern void init_scattered_cpuid_features(struct cpuinfo_x86 *c);
>extern unsigned int init_intel_cacheinfo(struct cpuinfo_x86 *c);
>extern unsigned short num_cache_leaves;
>
>
>
>
>static inline __attribute__((always_inline)) void detect_ht(struct cpuinfo_x86 *c) {}
>
>
>static inline __attribute__((always_inline)) void native_cpuid(unsigned int *eax, unsigned int *ebx,
>      unsigned int *ecx, unsigned int *edx)
>{
>
> __asm__("cpuid"
>  : "=a" (*eax),
>    "=b" (*ebx),
>    "=c" (*ecx),
>    "=d" (*edx)
>  : "0" (*eax), "2" (*ecx));
>}
># 157 "include/asm/processor_32.h"
>extern unsigned long mmu_cr4_features;
>
>static inline __attribute__((always_inline)) void set_in_cr4 (unsigned long mask)
>{
> unsigned cr4;
> mmu_cr4_features |= mask;
> cr4 = (native_read_cr4());
> cr4 |= mask;
> (native_write_cr4(cr4));
>}
>
>static inline __attribute__((always_inline)) void clear_in_cr4 (unsigned long mask)
>{
> unsigned cr4;
> mmu_cr4_features &= ~mask;
> cr4 = (native_read_cr4());
> cr4 &= ~mask;
> (native_write_cr4(cr4));
>}
>
>
>static inline __attribute__((always_inline)) void sync_core(void)
>{
> int tmp;
> asm volatile("cpuid" : "=a" (tmp) : "0" (1) : "ebx","ecx","edx","memory");
>}
>
>static inline __attribute__((always_inline)) void __monitor(const void *eax, unsigned long ecx,
>  unsigned long edx)
>{
>
> asm volatile(
>  ".byte 0x0f,0x01,0xc8;"
>  : :"a" (eax), "c" (ecx), "d"(edx));
>}
>
>static inline __attribute__((always_inline)) void __mwait(unsigned long eax, unsigned long ecx)
>{
>
> asm volatile(
>  ".byte 0x0f,0x01,0xc9;"
>  : :"a" (eax), "c" (ecx));
>}
>
>extern void mwait_idle_with_hints(unsigned long eax, unsigned long ecx);
>
>
>
>extern unsigned int machine_id;
>extern unsigned int machine_submodel_id;
>extern unsigned int BIOS_revision;
>extern unsigned int mca_pentium_flag;
>
>
>extern int bootloader_type;
># 225 "include/asm/processor_32.h"
>extern void hard_disable_TSC(void);
>extern void disable_TSC(void);
>extern void hard_enable_TSC(void);
># 239 "include/asm/processor_32.h"
>struct i387_fsave_struct {
> long cwd;
> long swd;
> long twd;
> long fip;
> long fcs;
> long foo;
> long fos;
> long st_space[20];
> long status;
>};
>
>struct i387_fxsave_struct {
> unsigned short cwd;
> unsigned short swd;
> unsigned short twd;
> unsigned short fop;
> long fip;
> long fcs;
> long foo;
> long fos;
> long mxcsr;
> long mxcsr_mask;
> long st_space[32];
> long xmm_space[32];
> long padding[56];
>} __attribute__ ((aligned (16)));
>
>struct i387_soft_struct {
> long cwd;
> long swd;
> long twd;
> long fip;
> long fcs;
> long foo;
> long fos;
> long st_space[20];
> unsigned char ftop, changed, lookahead, no_update, rm, alimit;
> struct info *info;
> unsigned long entry_eip;
>};
>
>union i387_union {
> struct i387_fsave_struct fsave;
> struct i387_fxsave_struct fxsave;
> struct i387_soft_struct soft;
>};
>
>typedef struct {
> unsigned long seg;
>} mm_segment_t;
>
>struct thread_struct;
>
>
>struct i386_hw_tss {
> unsigned short back_link,__blh;
> unsigned long esp0;
> unsigned short ss0,__ss0h;
> unsigned long esp1;
> unsigned short ss1,__ss1h;
> unsigned long esp2;
> unsigned short ss2,__ss2h;
> unsigned long __cr3;
> unsigned long eip;
> unsigned long eflags;
> unsigned long eax,ecx,edx,ebx;
> unsigned long esp;
> unsigned long ebp;
> unsigned long esi;
> unsigned long edi;
> unsigned short es, __esh;
> unsigned short cs, __csh;
> unsigned short ss, __ssh;
> unsigned short ds, __dsh;
> unsigned short fs, __fsh;
> unsigned short gs, __gsh;
> unsigned short ldt, __ldth;
> unsigned short trace, io_bitmap_base;
>} __attribute__((packed));
>
>struct tss_struct {
> struct i386_hw_tss x86_tss;
>
>
>
>
>
>
>
> unsigned long io_bitmap[((65536/8)/sizeof(long)) + 1];
>
>
>
> unsigned long io_bitmap_max;
> struct thread_struct *io_bitmap_owner;
>
>
>
> unsigned long __cacheline_filler[35];
>
>
>
> unsigned long stack[64];
>} __attribute__((packed));
>
>
>
>struct thread_struct {
>
> struct desc_struct tls_array[3];
> unsigned long esp0;
> unsigned long sysenter_cs;
> unsigned long eip;
> unsigned long esp;
> unsigned long fs;
> unsigned long gs;
>
> unsigned long debugreg[8];
>
> unsigned long cr2, trap_no, error_code;
>
> union i387_union i387;
>
> struct vm86_struct * vm86_info;
> unsigned long screen_bitmap;
> unsigned long v86flags, v86mask, saved_esp0;
> unsigned int saved_fs, saved_gs;
>
> unsigned long *io_bitmap_ptr;
>  unsigned long iopl;
>
> unsigned long io_bitmap_max;
>};
># 411 "include/asm/processor_32.h"
>struct task_struct;
>struct mm_struct;
>
>
>extern void release_thread(struct task_struct *);
>
>
>extern void prepare_to_copy(struct task_struct *tsk);
>
>
>
>
>extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
>
>extern unsigned long thread_saved_pc(struct task_struct *tsk);
>void show_trace(struct task_struct *task, struct pt_regs *regs, unsigned long *stack);
>
>unsigned long get_wchan(struct task_struct *p);
># 458 "include/asm/processor_32.h"
>struct microcode_header {
> unsigned int hdrver;
> unsigned int rev;
> unsigned int date;
> unsigned int sig;
> unsigned int cksum;
> unsigned int ldrver;
> unsigned int pf;
> unsigned int datasize;
> unsigned int totalsize;
> unsigned int reserved[3];
>};
>
>struct microcode {
> struct microcode_header hdr;
> unsigned int bits[0];
>};
>
>typedef struct microcode microcode_t;
>typedef struct microcode_header microcode_header_t;
>
>
>struct extended_signature {
> unsigned int sig;
> unsigned int pf;
> unsigned int cksum;
>};
>
>struct extended_sigtable {
> unsigned int count;
> unsigned int cksum;
> unsigned int reserved[3];
> struct extended_signature sigs[0];
>};
>
>
>static inline __attribute__((always_inline)) void rep_nop(void)
>{
> __asm__ __volatile__("rep;nop": : :"memory");
>}
>
>
>
>static inline __attribute__((always_inline)) void native_load_esp0(struct tss_struct *tss, struct thread_struct *thread)
>{
> tss->x86_tss.esp0 = thread->esp0;
>
> if (__builtin_expect(!!(tss->x86_tss.ss1 != thread->sysenter_cs), 0)) {
>  tss->x86_tss.ss1 = thread->sysenter_cs;
>  wrmsr(0x00000174, thread->sysenter_cs, 0);
> }
>}
>
>
>static inline __attribute__((always_inline)) unsigned long native_get_debugreg(int regno)
>{
> unsigned long val = 0;
>
> switch (regno) {
> case 0:
>  asm("movl %%db0, %0" :"=r" (val)); break;
> case 1:
>  asm("movl %%db1, %0" :"=r" (val)); break;
> case 2:
>  asm("movl %%db2, %0" :"=r" (val)); break;
> case 3:
>  asm("movl %%db3, %0" :"=r" (val)); break;
> case 6:
>  asm("movl %%db6, %0" :"=r" (val)); break;
> case 7:
>  asm("movl %%db7, %0" :"=r" (val)); break;
> default:
>  do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("include/asm/processor_32.h"), "i" (530), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0);
> }
> return val;
>}
>
>static inline __attribute__((always_inline)) void native_set_debugreg(int regno, unsigned long value)
>{
> switch (regno) {
> case 0:
>  asm("movl %0,%%db0" : :"r" (value));
>  break;
> case 1:
>  asm("movl %0,%%db1" : :"r" (value));
>  break;
> case 2:
>  asm("movl %0,%%db2" : :"r" (value));
>  break;
> case 3:
>  asm("movl %0,%%db3" : :"r" (value));
>  break;
> case 6:
>  asm("movl %0,%%db6" : :"r" (value));
>  break;
> case 7:
>  asm("movl %0,%%db7" : :"r" (value));
>  break;
> default:
>  do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("include/asm/processor_32.h"), "i" (557), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0);
> }
>}
>
>
>
>
>static inline __attribute__((always_inline)) void native_set_iopl_mask(unsigned mask)
>{
> unsigned int reg;
> __asm__ __volatile__ ("pushfl;"
>         "popl %0;"
>         "andl %1, %0;"
>         "orl %2, %0;"
>         "pushl %0;"
>         "popfl"
>    : "=&r" (reg)
>    : "i" (~0x00003000), "r" (mask));
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void load_esp0(struct tss_struct *tss, struct thread_struct *thread)
>{
> native_load_esp0(tss, thread);
>}
># 604 "include/asm/processor_32.h"
>static inline __attribute__((always_inline)) void cpuid(unsigned int op,
>    unsigned int *eax, unsigned int *ebx,
>    unsigned int *ecx, unsigned int *edx)
>{
> *eax = op;
> *ecx = 0;
> native_cpuid(eax, ebx, ecx, edx);
>}
>
>
>static inline __attribute__((always_inline)) void cpuid_count(unsigned int op, int count,
>          unsigned int *eax, unsigned int *ebx,
>          unsigned int *ecx, unsigned int *edx)
>{
> *eax = op;
> *ecx = count;
> native_cpuid(eax, ebx, ecx, edx);
>}
>
>
>
>
>static inline __attribute__((always_inline)) unsigned int cpuid_eax(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
> return eax;
>}
>static inline __attribute__((always_inline)) unsigned int cpuid_ebx(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
> return ebx;
>}
>static inline __attribute__((always_inline)) unsigned int cpuid_ecx(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
> return ecx;
>}
>static inline __attribute__((always_inline)) unsigned int cpuid_edx(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
> return edx;
>}
># 745 "include/asm/processor_32.h"
>static inline __attribute__((always_inline)) void prefetch(const void *x)
>{
> asm volatile ("661:\n\t" ".byte 0x66,0x66,0x66,0x90\n" "\n662:\n" ".section .altinstructions,\"a\"\n" "  .align 4\n" "  .long 661b\n" "  .long 663f\n" "  .byte %c0\n" "  .byte 662b-661b\n" "  .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" "prefetchnta (%1)" "\n664:\n" ".previous" :: "i" ((0*32+25)), "r" (x));
>
>
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void prefetchw(const void *x)
>{
> asm volatile ("661:\n\t" ".byte 0x66,0x66,0x66,0x90\n" "\n662:\n" ".section .altinstructions,\"a\"\n" "  .align 4\n" "  .long 661b\n" "  .long 663f\n" "  .byte %c0\n" "  .byte 662b-661b\n" "  .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" "prefetchw (%1)" "\n664:\n" ".previous" :: "i" ((1*32+31)), "r" (x));
>
>
>
>}
>
>
>extern void select_idle_routine(const struct cpuinfo_x86 *c);
>
>
>
>extern unsigned long boot_option_idle_override;
>extern void enable_sep_cpu(void);
>extern int sysenter_setup(void);
>
>
>extern struct Xgt_desc_struct early_gdt_descr;
>
>extern void cpu_set_gdt(int);
>extern void switch_to_new_gdt(void);
>extern void cpu_init(void);
>extern void init_gdt(int cpu);
>
>extern int force_mwait;
># 3 "include/asm/processor.h" 2
># 15 "include/linux/prefetch.h" 2
># 53 "include/linux/prefetch.h"
>static inline __attribute__((always_inline)) void prefetch_range(void *addr, size_t len)
>{
>
> char *cp;
> char *end = addr + len;
>
> for (cp = addr; cp < end; cp += (4*(1 << (7))))
>  prefetch(cp);
>
>}
># 9 "include/linux/list.h" 2
># 1 "include/asm/system.h" 1
># 10 "include/linux/list.h" 2
># 21 "include/linux/list.h"
>struct list_head {
> struct list_head *next, *prev;
>};
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void INIT_LIST_HEAD(struct list_head *list)
>{
> list->next = list;
> list->prev = list;
>}
># 43 "include/linux/list.h"
>static inline __attribute__((always_inline)) void __list_add(struct list_head *new,
>         struct list_head *prev,
>         struct list_head *next)
>{
> next->prev = new;
> new->next = next;
> new->prev = prev;
> prev->next = new;
>}
># 67 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
>{
> __list_add(new, head, head->next);
>}
># 84 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_add_tail(struct list_head *new, struct list_head *head)
>{
> __list_add(new, head->prev, head);
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void __list_add_rcu(struct list_head * new,
>  struct list_head * prev, struct list_head * next)
>{
> new->next = next;
> new->prev = prev;
> __asm__ __volatile__("": : :"memory");
> next->prev = new;
> prev->next = new;
>}
># 121 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_add_rcu(struct list_head *new, struct list_head *head)
>{
> __list_add_rcu(new, head, head->next);
>}
># 142 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_add_tail_rcu(struct list_head *new,
>     struct list_head *head)
>{
> __list_add_rcu(new, head->prev, head);
>}
># 155 "include/linux/list.h"
>static inline __attribute__((always_inline)) void __list_del(struct list_head * prev, struct list_head * next)
>{
> next->prev = prev;
> prev->next = next;
>}
># 168 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_del(struct list_head *entry)
>{
> __list_del(entry->prev, entry->next);
> entry->next = ((void *) 0x00100100);
> entry->prev = ((void *) 0x00200200);
>}
># 202 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_del_rcu(struct list_head *entry)
>{
> __list_del(entry->prev, entry->next);
> entry->prev = ((void *) 0x00200200);
>}
># 215 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_replace(struct list_head *old,
>    struct list_head *new)
>{
> new->next = old->next;
> new->next->prev = new;
> new->prev = old->prev;
> new->prev->next = new;
>}
>
>static inline __attribute__((always_inline)) void list_replace_init(struct list_head *old,
>     struct list_head *new)
>{
> list_replace(old, new);
> INIT_LIST_HEAD(old);
>}
># 239 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_replace_rcu(struct list_head *old,
>    struct list_head *new)
>{
> new->next = old->next;
> new->prev = old->prev;
> __asm__ __volatile__("": : :"memory");
> new->next->prev = new;
> new->prev->next = new;
> old->prev = ((void *) 0x00200200);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void list_del_init(struct list_head *entry)
>{
> __list_del(entry->prev, entry->next);
> INIT_LIST_HEAD(entry);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void list_move(struct list_head *list, struct list_head *head)
>{
> __list_del(list->prev, list->next);
> list_add(list, head);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void list_move_tail(struct list_head *list,
>      struct list_head *head)
>{
> __list_del(list->prev, list->next);
> list_add_tail(list, head);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int list_is_last(const struct list_head *list,
>    const struct list_head *head)
>{
> return list->next == head;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int list_empty(const struct list_head *head)
>{
> return head->next == head;
>}
># 316 "include/linux/list.h"
>static inline __attribute__((always_inline)) int list_empty_careful(const struct list_head *head)
>{
> struct list_head *next = head->next;
> return (next == head) && (next == head->prev);
>}
>
>static inline __attribute__((always_inline)) void __list_splice(struct list_head *list,
>     struct list_head *head)
>{
> struct list_head *first = list->next;
> struct list_head *last = list->prev;
> struct list_head *at = head->next;
>
> first->prev = head;
> head->next = first;
>
> last->next = at;
> at->prev = last;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void list_splice(struct list_head *list, struct list_head *head)
>{
> if (!list_empty(list))
>  __list_splice(list, head);
>}
># 354 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_splice_init(struct list_head *list,
>        struct list_head *head)
>{
> if (!list_empty(list)) {
>  __list_splice(list, head);
>  INIT_LIST_HEAD(list);
> }
>}
># 380 "include/linux/list.h"
>static inline __attribute__((always_inline)) void list_splice_init_rcu(struct list_head *list,
>     struct list_head *head,
>     void (*sync)(void))
>{
> struct list_head *first = list->next;
> struct list_head *last = list->prev;
> struct list_head *at = head->next;
>
> if (list_empty(head))
>  return;
>
>
>
> INIT_LIST_HEAD(list);
># 402 "include/linux/list.h"
> sync();
># 412 "include/linux/list.h"
> last->next = at;
> __asm__ __volatile__("": : :"memory");
> head->next = first;
> first->prev = head;
> at->prev = last;
>}
># 700 "include/linux/list.h"
>struct hlist_head {
> struct hlist_node *first;
>};
>
>struct hlist_node {
> struct hlist_node *next, **pprev;
>};
>
>
>
>
>static inline __attribute__((always_inline)) void INIT_HLIST_NODE(struct hlist_node *h)
>{
> h->next = ((void *)0);
> h->pprev = ((void *)0);
>}
>
>static inline __attribute__((always_inline)) int hlist_unhashed(const struct hlist_node *h)
>{
> return !h->pprev;
>}
>
>static inline __attribute__((always_inline)) int hlist_empty(const struct hlist_head *h)
>{
> return !h->first;
>}
>
>static inline __attribute__((always_inline)) void __hlist_del(struct hlist_node *n)
>{
> struct hlist_node *next = n->next;
> struct hlist_node **pprev = n->pprev;
> *pprev = next;
> if (next)
>  next->pprev = pprev;
>}
>
>static inline __attribute__((always_inline)) void hlist_del(struct hlist_node *n)
>{
> __hlist_del(n);
> n->next = ((void *) 0x00100100);
> n->pprev = ((void *) 0x00200200);
>}
># 762 "include/linux/list.h"
>static inline __attribute__((always_inline)) void hlist_del_rcu(struct hlist_node *n)
>{
> __hlist_del(n);
> n->pprev = ((void *) 0x00200200);
>}
>
>static inline __attribute__((always_inline)) void hlist_del_init(struct hlist_node *n)
>{
> if (!hlist_unhashed(n)) {
>  __hlist_del(n);
>  INIT_HLIST_NODE(n);
> }
>}
># 783 "include/linux/list.h"
>static inline __attribute__((always_inline)) void hlist_replace_rcu(struct hlist_node *old,
>     struct hlist_node *new)
>{
> struct hlist_node *next = old->next;
>
> new->next = next;
> new->pprev = old->pprev;
> __asm__ __volatile__("": : :"memory");
> if (next)
>  new->next->pprev = &new->next;
> *new->pprev = new;
> old->pprev = ((void *) 0x00200200);
>}
>
>static inline __attribute__((always_inline)) void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
>{
> struct hlist_node *first = h->first;
> n->next = first;
> if (first)
>  first->pprev = &n->next;
> h->first = n;
> n->pprev = &h->first;
>}
># 827 "include/linux/list.h"
>static inline __attribute__((always_inline)) void hlist_add_head_rcu(struct hlist_node *n,
>     struct hlist_head *h)
>{
> struct hlist_node *first = h->first;
> n->next = first;
> n->pprev = &h->first;
> __asm__ __volatile__("": : :"memory");
> if (first)
>  first->pprev = &n->next;
> h->first = n;
>}
>
>
>static inline __attribute__((always_inline)) void hlist_add_before(struct hlist_node *n,
>     struct hlist_node *next)
>{
> n->pprev = next->pprev;
> n->next = next;
> next->pprev = &n->next;
> *(n->pprev) = n;
>}
>
>static inline __attribute__((always_inline)) void hlist_add_after(struct hlist_node *n,
>     struct hlist_node *next)
>{
> next->next = n->next;
> n->next = next;
> next->pprev = &n->next;
>
> if(next->next)
>  next->next->pprev = &next->next;
>}
># 878 "include/linux/list.h"
>static inline __attribute__((always_inline)) void hlist_add_before_rcu(struct hlist_node *n,
>     struct hlist_node *next)
>{
> n->pprev = next->pprev;
> n->next = next;
> __asm__ __volatile__("": : :"memory");
> next->pprev = &n->next;
> *(n->pprev) = n;
>}
># 906 "include/linux/list.h"
>static inline __attribute__((always_inline)) void hlist_add_after_rcu(struct hlist_node *prev,
>           struct hlist_node *n)
>{
> n->next = prev->next;
> n->pprev = &prev->next;
> __asm__ __volatile__("": : :"memory");
> prev->next = n;
> if (n->next)
>  n->next->pprev = &n->next;
>}
># 24 "include/linux/kobject.h" 2
># 1 "include/linux/sysfs.h" 1
># 18 "include/linux/sysfs.h"
># 1 "include/asm/atomic.h" 1
>
># 1 "include/asm/atomic_32.h" 1
>
>
>
>
># 1 "include/asm/processor.h" 1
># 6 "include/asm/atomic_32.h" 2
># 1 "include/asm/cmpxchg.h" 1
># 7 "include/asm/atomic_32.h" 2
># 18 "include/asm/atomic_32.h"
>typedef struct { int counter; } atomic_t;
># 46 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) void atomic_add(int i, atomic_t *v)
>{
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "addl %1,%0"
>  :"+m" (v->counter)
>  :"ir" (i));
>}
># 61 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) void atomic_sub(int i, atomic_t *v)
>{
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "subl %1,%0"
>  :"+m" (v->counter)
>  :"ir" (i));
>}
># 78 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_sub_and_test(int i, atomic_t *v)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "subl %2,%0; sete %1"
>  :"+m" (v->counter), "=qm" (c)
>  :"ir" (i) : "memory");
> return c;
>}
>
>
>
>
>
>
>
>static __inline__ __attribute__((always_inline)) void atomic_inc(atomic_t *v)
>{
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "incl %0"
>  :"+m" (v->counter));
>}
>
>
>
>
>
>
>
>static __inline__ __attribute__((always_inline)) void atomic_dec(atomic_t *v)
>{
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "decl %0"
>  :"+m" (v->counter));
>}
># 123 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_dec_and_test(atomic_t *v)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "decl %0; sete %1"
>  :"+m" (v->counter), "=qm" (c)
>  : : "memory");
> return c != 0;
>}
># 142 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_inc_and_test(atomic_t *v)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "incl %0; sete %1"
>  :"+m" (v->counter), "=qm" (c)
>  : : "memory");
> return c != 0;
>}
># 162 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_add_negative(int i, atomic_t *v)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "addl %2,%0; sets %1"
>  :"+m" (v->counter), "=qm" (c)
>  :"ir" (i) : "memory");
> return c;
>}
># 180 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_add_return(int i, atomic_t *v)
>{
> int __i;
>
>
>
>
>
>
> __i = i;
> __asm__ __volatile__(
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "xaddl %0, %1"
>  :"+r" (i), "+m" (v->counter)
>  : : "memory");
> return i + __i;
># 204 "include/asm/atomic_32.h"
>}
># 213 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_sub_return(int i, atomic_t *v)
>{
> return atomic_add_return(-i,v);
>}
># 230 "include/asm/atomic_32.h"
>static __inline__ __attribute__((always_inline)) int atomic_add_unless(atomic_t *v, int a, int u)
>{
> int c, old;
> c = ((v)->counter);
> for (;;) {
>  if (__builtin_expect(!!(c == (u)), 0))
>   break;
>  old = (((__typeof__(*(&(((v))->counter))))__cmpxchg((&(((v))->counter)),(unsigned long)((c)), (unsigned long)((c + (a))),sizeof(*(&(((v))->counter))))));
>  if (__builtin_expect(!!(old == c), 1))
>   break;
>  c = old;
> }
> return c != (u);
>}
># 265 "include/asm/atomic_32.h"
># 1 "include/asm-generic/atomic.h" 1
># 141 "include/asm-generic/atomic.h"
>typedef atomic_t atomic_long_t;
>
>
>static inline __attribute__((always_inline)) long atomic_long_read(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return (long)((v)->counter);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_set(atomic_long_t *l, long i)
>{
> atomic_t *v = (atomic_t *)l;
>
> (((v)->counter) = (i));
>}
>
>static inline __attribute__((always_inline)) void atomic_long_inc(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> atomic_inc(v);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_dec(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> atomic_dec(v);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_add(long i, atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> atomic_add(i, v);
>}
>
>static inline __attribute__((always_inline)) void atomic_long_sub(long i, atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> atomic_sub(i, v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_sub_and_test(long i, atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return atomic_sub_and_test(i, v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_dec_and_test(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return atomic_dec_and_test(v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_inc_and_test(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return atomic_inc_and_test(v);
>}
>
>static inline __attribute__((always_inline)) int atomic_long_add_negative(long i, atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return atomic_add_negative(i, v);
>}
>
>static inline __attribute__((always_inline)) long atomic_long_add_return(long i, atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return (long)atomic_add_return(i, v);
>}
>
>static inline __attribute__((always_inline)) long atomic_long_sub_return(long i, atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return (long)atomic_sub_return(i, v);
>}
>
>static inline __attribute__((always_inline)) long atomic_long_inc_return(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return (long)(atomic_add_return(1,v));
>}
>
>static inline __attribute__((always_inline)) long atomic_long_dec_return(atomic_long_t *l)
>{
> atomic_t *v = (atomic_t *)l;
>
> return (long)(atomic_sub_return(1,v));
>}
>
>static inline __attribute__((always_inline)) long atomic_long_add_unless(atomic_long_t *l, long a, long u)
>{
> atomic_t *v = (atomic_t *)l;
>
> return (long)atomic_add_unless(v, a, u);
>}
># 266 "include/asm/atomic_32.h" 2
># 3 "include/asm/atomic.h" 2
># 19 "include/linux/sysfs.h" 2
>
>struct kobject;
>struct module;
>
>
>
>
>
>struct attribute {
> const char *name;
> struct module *owner;
> mode_t mode;
>};
>
>struct attribute_group {
> const char *name;
> struct attribute **attrs;
>};
># 60 "include/linux/sysfs.h"
>struct vm_area_struct;
>
>struct bin_attribute {
> struct attribute attr;
> size_t size;
> void *private;
> ssize_t (*read)(struct kobject *, struct bin_attribute *,
>   char *, loff_t, size_t);
> ssize_t (*write)(struct kobject *, struct bin_attribute *,
>    char *, loff_t, size_t);
> int (*mmap)(struct kobject *, struct bin_attribute *attr,
>      struct vm_area_struct *vma);
>};
>
>struct sysfs_ops {
> ssize_t (*show)(struct kobject *, struct attribute *,char *);
> ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
>};
>
>
>
>int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
>       void *data, struct module *owner);
>
>int __attribute__((warn_unused_result)) sysfs_create_dir(struct kobject *kobj);
>void sysfs_remove_dir(struct kobject *kobj);
>int __attribute__((warn_unused_result)) sysfs_rename_dir(struct kobject *kobj, const char *new_name);
>int __attribute__((warn_unused_result)) sysfs_move_dir(struct kobject *kobj,
>    struct kobject *new_parent_kobj);
>
>int __attribute__((warn_unused_result)) sysfs_create_file(struct kobject *kobj,
>       const struct attribute *attr);
>int __attribute__((warn_unused_result)) sysfs_chmod_file(struct kobject *kobj, struct attribute *attr,
>      mode_t mode);
>void sysfs_remove_file(struct kobject *kobj, const struct attribute *attr);
>
>int __attribute__((warn_unused_result)) sysfs_create_bin_file(struct kobject *kobj,
>           struct bin_attribute *attr);
>void sysfs_remove_bin_file(struct kobject *kobj, struct bin_attribute *attr);
>
>int __attribute__((warn_unused_result)) sysfs_create_link(struct kobject *kobj, struct kobject *target,
>       const char *name);
>void sysfs_remove_link(struct kobject *kobj, const char *name);
>
>int __attribute__((warn_unused_result)) sysfs_create_group(struct kobject *kobj,
>        const struct attribute_group *grp);
>void sysfs_remove_group(struct kobject *kobj,
>   const struct attribute_group *grp);
>int sysfs_add_file_to_group(struct kobject *kobj,
>   const struct attribute *attr, const char *group);
>void sysfs_remove_file_from_group(struct kobject *kobj,
>   const struct attribute *attr, const char *group);
>
>void sysfs_notify(struct kobject *kobj, char *dir, char *attr);
>
>extern int __attribute__((warn_unused_result)) sysfs_init(void);
># 25 "include/linux/kobject.h" 2
>
># 1 "include/linux/spinlock.h" 1
># 49 "include/linux/spinlock.h"
># 1 "include/linux/preempt.h" 1
># 9 "include/linux/preempt.h"
># 1 "include/linux/thread_info.h" 1
># 13 "include/linux/thread_info.h"
>struct restart_block {
> long (*fn)(struct restart_block *);
> unsigned long arg0, arg1, arg2, arg3;
>};
>
>extern long do_no_restart_syscall(struct restart_block *parm);
>
>
># 1 "include/asm/thread_info.h" 1
>
># 1 "include/asm/thread_info_32.h" 1
># 13 "include/asm/thread_info_32.h"
># 1 "include/asm/page.h" 1
># 14 "include/asm/thread_info_32.h" 2
>
>
># 1 "include/asm/processor.h" 1
># 17 "include/asm/thread_info_32.h" 2
># 27 "include/asm/thread_info_32.h"
>struct thread_info {
> struct task_struct *task;
> struct exec_domain *exec_domain;
> unsigned long flags;
> unsigned long status;
> __u32 cpu;
> int preempt_count;
>
>
> mm_segment_t addr_limit;
>
>
>
> void *sysenter_return;
> struct restart_block restart_block;
>
> unsigned long previous_esp;
>
>
> __u8 supervisor_stack[0];
>};
># 88 "include/asm/thread_info_32.h"
>register unsigned long current_stack_pointer asm("esp") __attribute__((__used__));
>
>
>static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
>{
> return (struct thread_info *)(current_stack_pointer & ~((4096) - 1));
>}
># 3 "include/asm/thread_info.h" 2
># 22 "include/linux/thread_info.h" 2
># 30 "include/linux/thread_info.h"
>static inline __attribute__((always_inline)) void set_ti_thread_flag(struct thread_info *ti, int flag)
>{
> set_bit(flag,&ti->flags);
>}
>
>static inline __attribute__((always_inline)) void clear_ti_thread_flag(struct thread_info *ti, int flag)
>{
> clear_bit(flag,&ti->flags);
>}
>
>static inline __attribute__((always_inline)) int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
>{
> return test_and_set_bit(flag,&ti->flags);
>}
>
>static inline __attribute__((always_inline)) int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
>{
> return test_and_clear_bit(flag,&ti->flags);
>}
>
>static inline __attribute__((always_inline)) int test_ti_thread_flag(struct thread_info *ti, int flag)
>{
> return (__builtin_constant_p(flag) ? constant_test_bit((flag),(&ti->flags)) : variable_test_bit((flag),(&ti->flags)));
>}
># 10 "include/linux/preempt.h" 2
># 66 "include/linux/preempt.h"
>struct preempt_notifier;
># 77 "include/linux/preempt.h"
>struct preempt_ops {
> void (*sched_in)(struct preempt_notifier *notifier, int cpu);
> void (*sched_out)(struct preempt_notifier *notifier,
>     struct task_struct *next);
>};
># 90 "include/linux/preempt.h"
>struct preempt_notifier {
> struct hlist_node link;
> struct preempt_ops *ops;
>};
>
>void preempt_notifier_register(struct preempt_notifier *notifier);
>void preempt_notifier_unregister(struct preempt_notifier *notifier);
>
>static inline __attribute__((always_inline)) void preempt_notifier_init(struct preempt_notifier *notifier,
>         struct preempt_ops *ops)
>{
> INIT_HLIST_NODE(&notifier->link);
> notifier->ops = ops;
>}
># 50 "include/linux/spinlock.h" 2
>
>
>
>
># 1 "include/linux/stringify.h" 1
># 55 "include/linux/spinlock.h" 2
># 1 "include/linux/bottom_half.h" 1
>
>
>
>extern void local_bh_disable(void);
>extern void __local_bh_enable(void);
>extern void _local_bh_enable(void);
>extern void local_bh_enable(void);
>extern void local_bh_enable_ip(unsigned long ip);
># 56 "include/linux/spinlock.h" 2
>
># 1 "include/asm/system.h" 1
># 58 "include/linux/spinlock.h" 2
># 79 "include/linux/spinlock.h"
># 1 "include/linux/spinlock_types.h" 1
># 13 "include/linux/spinlock_types.h"
># 1 "include/asm/spinlock_types.h" 1
>
>
>
>
>
>
>
>typedef struct {
> unsigned int slock;
>} raw_spinlock_t;
>
>
>
>typedef struct {
> unsigned int lock;
>} raw_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;
># 313 "include/linux/lockdep.h"
>static inline __attribute__((always_inline)) void lockdep_off(void)
>{
>}
>
>static inline __attribute__((always_inline)) void lockdep_on(void)
>{
>}
># 340 "include/linux/lockdep.h"
>struct lock_class_key { };
># 373 "include/linux/lockdep.h"
>static inline __attribute__((always_inline)) void early_init_irq_lock_class(void)
>{
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void early_boot_irqs_off(void)
>{
>}
>static inline __attribute__((always_inline)) void early_boot_irqs_on(void)
>{
>}
>static inline __attribute__((always_inline)) void print_irqtrace_events(struct task_struct *curr)
>{
>}
># 19 "include/linux/spinlock_types.h" 2
>
>typedef struct {
> raw_spinlock_t raw_lock;
># 32 "include/linux/spinlock_types.h"
>} spinlock_t;
>
>
>
>typedef struct {
> raw_rwlock_t raw_lock;
># 48 "include/linux/spinlock_types.h"
>} rwlock_t;
># 80 "include/linux/spinlock.h" 2
>
>extern int __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) generic__raw_read_trylock(raw_rwlock_t *lock);
>
>
>
>
>
># 1 "include/asm/spinlock.h" 1
>
># 1 "include/asm/spinlock_32.h" 1
>
>
>
># 1 "include/asm/atomic.h" 1
># 5 "include/asm/spinlock_32.h" 2
># 1 "include/asm/rwlock.h" 1
># 6 "include/asm/spinlock_32.h" 2
># 1 "include/asm/page.h" 1
># 7 "include/asm/spinlock_32.h" 2
># 1 "include/asm/processor.h" 1
># 8 "include/asm/spinlock_32.h" 2
># 30 "include/asm/spinlock_32.h"
>static inline __attribute__((always_inline)) int __raw_spin_is_locked(raw_spinlock_t *x)
>{
> return *(volatile signed char *)(&(x)->slock) <= 0;
>}
>
>static inline __attribute__((always_inline)) void __raw_spin_lock(raw_spinlock_t *lock)
>{
> asm volatile("\n1:\t"
>       ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " " ; decb %0\n\t"
>       "jns 3f\n"
>       "2:\t"
>       "rep;nop\n\t"
>       "cmpb $0,%0\n\t"
>       "jle 2b\n\t"
>       "jmp 1b\n"
>       "3:\n\t"
>       : "+m" (lock->slock) : : "memory");
>}
># 58 "include/asm/spinlock_32.h"
>static inline __attribute__((always_inline)) void __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long flags)
>{
> asm volatile(
>  "\n1:\t"
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " " ; decb %[slock]\n\t"
>  "jns 5f\n"
>  "2:\t"
>  "testl $0x200, %[flags]\n\t"
>  "jz 4f\n\t"
>  "sti" "\n"
>  "3:\t"
>  "rep;nop\n\t"
>  "cmpb $0, %[slock]\n\t"
>  "jle 3b\n\t"
>  "cli" "\n\t"
>  "jmp 1b\n"
>  "4:\t"
>  "rep;nop\n\t"
>  "cmpb $0, %[slock]\n\t"
>  "jg 1b\n\t"
>  "jmp 4b\n"
>  "5:\n\t"
>  : [slock] "+m" (lock->slock)
>  : [flags] "r" (flags)
>    
>  : "memory" );
>}
>
>
>static inline __attribute__((always_inline)) int __raw_spin_trylock(raw_spinlock_t *lock)
>{
> char oldval;
> asm volatile(
>  "xchgb %b0,%1"
>  :"=q" (oldval), "+m" (lock->slock)
>  :"0" (0) : "memory");
> return oldval > 0;
>}
># 106 "include/asm/spinlock_32.h"
>static inline __attribute__((always_inline)) void __raw_spin_unlock(raw_spinlock_t *lock)
>{
> asm volatile("movb $1,%0" : "+m" (lock->slock) :: "memory");
>}
># 124 "include/asm/spinlock_32.h"
>static inline __attribute__((always_inline)) void __raw_spin_unlock_wait(raw_spinlock_t *lock)
>{
> while (__raw_spin_is_locked(lock))
>  rep_nop();
>}
># 155 "include/asm/spinlock_32.h"
>static inline __attribute__((always_inline)) int __raw_read_can_lock(raw_rwlock_t *x)
>{
> return (int)(x)->lock > 0;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int __raw_write_can_lock(raw_rwlock_t *x)
>{
> return (x)->lock == 0x01000000;
>}
>
>static inline __attribute__((always_inline)) void __raw_read_lock(raw_rwlock_t *rw)
>{
> asm volatile(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " " subl $1,(%0)\n\t"
>       "jns 1f\n"
>       "call __read_lock_failed\n\t"
>       "1:\n"
>       ::"a" (rw) : "memory");
>}
>
>static inline __attribute__((always_inline)) void __raw_write_lock(raw_rwlock_t *rw)
>{
> asm volatile(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " " subl $" "0x01000000" ",(%0)\n\t"
>       "jz 1f\n"
>       "call __write_lock_failed\n\t"
>       "1:\n"
>       ::"a" (rw) : "memory");
>}
>
>static inline __attribute__((always_inline)) int __raw_read_trylock(raw_rwlock_t *lock)
>{
> atomic_t *count = (atomic_t *)lock;
> atomic_dec(count);
> if (((count)->counter) >= 0)
>  return 1;
> atomic_inc(count);
> return 0;
>}
>
>static inline __attribute__((always_inline)) int __raw_write_trylock(raw_rwlock_t *lock)
>{
> atomic_t *count = (atomic_t *)lock;
> if (atomic_sub_and_test(0x01000000, count))
>  return 1;
> atomic_add(0x01000000, count);
> return 0;
>}
>
>static inline __attribute__((always_inline)) void __raw_read_unlock(raw_rwlock_t *rw)
>{
> asm volatile(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "incl %0" :"+m" (rw->lock) : : "memory");
>}
>
>static inline __attribute__((always_inline)) void __raw_write_unlock(raw_rwlock_t *rw)
>{
> asm volatile(".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "addl $" "0x01000000" ", %0"
>     : "+m" (rw->lock) : : "memory");
>}
># 3 "include/asm/spinlock.h" 2
># 88 "include/linux/spinlock.h" 2
># 133 "include/linux/spinlock.h"
># 1 "include/linux/spinlock_api_smp.h" 1
># 18 "include/linux/spinlock_api_smp.h"
>int in_lock_functions(unsigned long addr);
>
>
>
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_lock(spinlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_lock_nested(spinlock_t *lock, int subclass)
>       ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_lock(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_lock(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_lock_bh(spinlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_lock_bh(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_lock_bh(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_lock_irq(spinlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_lock_irq(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_lock_irq(rwlock_t *lock) ;
>unsigned long __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_lock_irqsave(spinlock_t *lock)
>       ;
>unsigned long __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_lock_irqsave_nested(spinlock_t *lock, int subclass)
>       ;
>unsigned long __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_lock_irqsave(rwlock_t *lock)
>       ;
>unsigned long __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_lock_irqsave(rwlock_t *lock)
>       ;
>int __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_trylock(spinlock_t *lock);
>int __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_trylock(rwlock_t *lock);
>int __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_trylock(rwlock_t *lock);
>int __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_trylock_bh(spinlock_t *lock);
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_unlock(spinlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_unlock(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_unlock(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_unlock_bh(spinlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_unlock_bh(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_unlock_bh(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_unlock_irq(spinlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_unlock_irq(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_unlock_irq(rwlock_t *lock) ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
>       ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
>       ;
>void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
>       ;
># 134 "include/linux/spinlock.h" 2
># 296 "include/linux/spinlock.h"
>static inline __attribute__((always_inline)) void double_spin_lock(spinlock_t *l1, spinlock_t *l2,
>        bool l1_first)
>
>
>{
> if (l1_first) {
>  _spin_lock(l1);
>  _spin_lock(l2);
> } else {
>  _spin_lock(l2);
>  _spin_lock(l1);
> }
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void double_spin_unlock(spinlock_t *l1, spinlock_t *l2,
>          bool l1_taken_first)
>
>
>{
> if (l1_taken_first) {
>  do {__raw_spin_unlock(&(l2)->raw_lock); (void)0; } while (0);
>  do {__raw_spin_unlock(&(l1)->raw_lock); (void)0; } while (0);
> } else {
>  do {__raw_spin_unlock(&(l1)->raw_lock); (void)0; } while (0);
>  do {__raw_spin_unlock(&(l2)->raw_lock); (void)0; } while (0);
> }
>}
>
>
>
>
>
># 1 "include/asm/atomic.h" 1
># 334 "include/linux/spinlock.h" 2
>
>
>
>
>
>extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
># 27 "include/linux/kobject.h" 2
># 1 "include/linux/kref.h" 1
># 21 "include/linux/kref.h"
># 1 "include/asm/atomic.h" 1
># 22 "include/linux/kref.h" 2
>
>struct kref {
> atomic_t refcount;
>};
>
>void kref_init(struct kref *kref);
>void kref_get(struct kref *kref);
>int kref_put(struct kref *kref, void (*release) (struct kref *kref));
># 28 "include/linux/kobject.h" 2
>
># 1 "include/linux/wait.h" 1
># 25 "include/linux/wait.h"
># 1 "include/asm/system.h" 1
># 26 "include/linux/wait.h" 2
># 1 "include/asm/current.h" 1
>
># 1 "include/asm/current_32.h" 1
>
>
>
>
># 1 "include/asm/percpu.h" 1
># 6 "include/asm/current_32.h" 2
>
>struct task_struct;
>
>extern __typeof__(struct task_struct *) per_cpu__current_task;
>static inline __attribute__((always_inline)) __attribute__((always_inline)) struct task_struct *get_current(void)
>{
> return ({ typeof(per_cpu__current_task) ret__; switch (sizeof(per_cpu__current_task)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__current_task)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__current_task)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__current_task)); break; default: __bad_percpu_size(); } ret__; });
>}
># 3 "include/asm/current.h" 2
># 27 "include/linux/wait.h" 2
>
>typedef struct __wait_queue wait_queue_t;
>typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key);
>int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
>
>struct __wait_queue {
> unsigned int flags;
>
> void *private;
> wait_queue_func_t func;
> struct list_head task_list;
>};
>
>struct wait_bit_key {
> void *flags;
> int bit_nr;
>};
>
>struct wait_bit_queue {
> struct wait_bit_key key;
> wait_queue_t wait;
>};
>
>struct __wait_queue_head {
> spinlock_t lock;
> struct list_head task_list;
>};
>typedef struct __wait_queue_head wait_queue_head_t;
>
>struct task_struct;
># 80 "include/linux/wait.h"
>extern void init_waitqueue_head(wait_queue_head_t *q);
># 91 "include/linux/wait.h"
>static inline __attribute__((always_inline)) void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
>{
> q->flags = 0;
> q->private = p;
> q->func = default_wake_function;
>}
>
>static inline __attribute__((always_inline)) void init_waitqueue_func_entry(wait_queue_t *q,
>     wait_queue_func_t func)
>{
> q->flags = 0;
> q->private = ((void *)0);
> q->func = func;
>}
>
>static inline __attribute__((always_inline)) int waitqueue_active(wait_queue_head_t *q)
>{
> return !list_empty(&q->task_list);
>}
># 120 "include/linux/wait.h"
>extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait) __attribute__((regparm(3)));
>extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait) __attribute__((regparm(3)));
>extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait) __attribute__((regparm(3)));
>
>static inline __attribute__((always_inline)) void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
>{
> list_add(&new->task_list, &head->task_list);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void __add_wait_queue_tail(wait_queue_head_t *head,
>      wait_queue_t *new)
>{
> list_add_tail(&new->task_list, &head->task_list);
>}
>
>static inline __attribute__((always_inline)) void __remove_wait_queue(wait_queue_head_t *head,
>       wait_queue_t *old)
>{
> list_del(&old->task_list);
>}
>
>void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key) __attribute__((regparm(3)));
>extern void __wake_up_locked(wait_queue_head_t *q, unsigned int mode) __attribute__((regparm(3)));
>extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr) __attribute__((regparm(3)));
>void __wake_up_bit(wait_queue_head_t *, void *, int) __attribute__((regparm(3)));
>int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned) __attribute__((regparm(3)));
>int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned) __attribute__((regparm(3)));
>void wake_up_bit(void *, int) __attribute__((regparm(3)));
>int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned) __attribute__((regparm(3)));
>int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned) __attribute__((regparm(3)));
>wait_queue_head_t *bit_waitqueue(void *, int) __attribute__((regparm(3)));
># 351 "include/linux/wait.h"
>static inline __attribute__((always_inline)) void add_wait_queue_exclusive_locked(wait_queue_head_t *q,
>         wait_queue_t * wait)
>{
> wait->flags |= 0x01;
> __add_wait_queue_tail(q, wait);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void remove_wait_queue_locked(wait_queue_head_t *q,
>         wait_queue_t * wait)
>{
> __remove_wait_queue(q, wait);
>}
>
>
>
>
>
>
>extern void sleep_on(wait_queue_head_t *q);
>extern long sleep_on_timeout(wait_queue_head_t *q,
>          signed long timeout);
>extern void interruptible_sleep_on(wait_queue_head_t *q);
>extern long interruptible_sleep_on_timeout(wait_queue_head_t *q,
>        signed long timeout);
>
>
>
>
>void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state) __attribute__((regparm(3)));
>
>void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state) __attribute__((regparm(3)));
>
>void finish_wait(wait_queue_head_t *q, wait_queue_t *wait) __attribute__((regparm(3)));
>int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
>int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
># 429 "include/linux/wait.h"
>static inline __attribute__((always_inline)) int wait_on_bit(void *word, int bit,
>    int (*action)(void *), unsigned mode)
>{
> if (!(__builtin_constant_p(bit) ? constant_test_bit((bit),(word)) : variable_test_bit((bit),(word))))
>  return 0;
> return out_of_line_wait_on_bit(word, bit, action, mode);
>}
># 453 "include/linux/wait.h"
>static inline __attribute__((always_inline)) int wait_on_bit_lock(void *word, int bit,
>    int (*action)(void *), unsigned mode)
>{
> if (!test_and_set_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit_lock(word, bit, action, mode);
>}
># 30 "include/linux/kobject.h" 2
># 1 "include/asm/atomic.h" 1
># 31 "include/linux/kobject.h" 2
>
>
>
>
>
>
>
>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 * k_name;
> struct kref kref;
> struct list_head entry;
> struct kobject * parent;
> struct kset * kset;
> struct kobj_type * ktype;
> struct sysfs_dirent * sd;
>};
>
>extern int kobject_set_name(struct kobject *, const char *, ...)
> __attribute__((format(printf,2,3)));
>
>static inline __attribute__((always_inline)) const char * kobject_name(const struct kobject * kobj)
>{
> return kobj->k_name;
>}
>
>extern void kobject_init(struct kobject *);
>extern void kobject_cleanup(struct kobject *);
>
>extern int __attribute__((warn_unused_result)) kobject_add(struct kobject *);
>extern void kobject_del(struct kobject *);
>
>extern int __attribute__((warn_unused_result)) kobject_rename(struct kobject *, const char *new_name);
>extern int __attribute__((warn_unused_result)) kobject_move(struct kobject *, struct kobject *);
>
>extern int __attribute__((warn_unused_result)) kobject_register(struct kobject *);
>extern void kobject_unregister(struct kobject *);
>
>extern struct kobject * kobject_get(struct kobject *);
>extern void kobject_put(struct kobject *);
>
>extern struct kobject *kobject_kset_add_dir(struct kset *kset,
>         struct kobject *, const char *);
>extern struct kobject *kobject_add_dir(struct kobject *, const char *);
>
>extern char * kobject_get_path(struct kobject *, gfp_t);
>
>struct kobj_type {
> void (*release)(struct kobject *);
> struct sysfs_ops * sysfs_ops;
> struct attribute ** default_attrs;
>};
>
>struct kobj_uevent_env {
> char *envp[32];
> int envp_idx;
> char buf[2048];
> int buflen;
>};
>
>struct kset_uevent_ops {
> int (*filter)(struct kset *kset, struct kobject *kobj);
> const char *(*name)(struct kset *kset, struct kobject *kobj);
> int (*uevent)(struct kset *kset, struct kobject *kobj,
>        struct kobj_uevent_env *env);
>};
># 140 "include/linux/kobject.h"
>struct kset {
> struct kobj_type *ktype;
> struct list_head list;
> spinlock_t list_lock;
> struct kobject kobj;
> struct kset_uevent_ops *uevent_ops;
>};
>
>
>extern void kset_init(struct kset * k);
>extern int __attribute__((warn_unused_result)) kset_add(struct kset * k);
>extern int __attribute__((warn_unused_result)) kset_register(struct kset * k);
>extern void kset_unregister(struct kset * k);
>
>static inline __attribute__((always_inline)) struct kset * to_kset(struct kobject * kobj)
>{
> return kobj ? ({ const typeof( ((struct kset *)0)->kobj ) *__mptr = (kobj); (struct kset *)( (char *)__mptr - __builtin_offsetof(struct kset,kobj) );}) : ((void *)0);
>}
>
>static inline __attribute__((always_inline)) struct kset * kset_get(struct kset * k)
>{
> return k ? to_kset(kobject_get(&k->kobj)) : ((void *)0);
>}
>
>static inline __attribute__((always_inline)) void kset_put(struct kset * k)
>{
> kobject_put(&k->kobj);
>}
>
>static inline __attribute__((always_inline)) struct kobj_type * get_ktype(struct kobject * k)
>{
> if (k->kset && k->kset->ktype)
>  return k->kset->ktype;
> else
>  return k->ktype;
>}
>
>extern struct kobject * kset_find_obj(struct kset *, const char *);
># 201 "include/linux/kobject.h"
>extern struct kset kernel_subsys;
>
>extern struct kset hypervisor_subsys;
># 223 "include/linux/kobject.h"
>extern int __attribute__((warn_unused_result)) subsystem_register(struct kset *);
>extern void subsystem_unregister(struct kset *);
>
>struct subsys_attribute {
> struct attribute attr;
> ssize_t (*show)(struct kset *, char *);
> ssize_t (*store)(struct kset *, const char *, size_t);
>};
>
>extern int __attribute__((warn_unused_result)) subsys_create_file(struct kset *,
>     struct subsys_attribute *);
>
>
>int kobject_uevent(struct kobject *kobj, enum kobject_action action);
>int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
>   char *envp[]);
>
>int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
> __attribute__((format (printf, 2, 3)));
>
>int kobject_action_type(const char *buf, size_t count,
>   enum kobject_action *type);
># 25 "include/linux/sysdev.h" 2
># 1 "include/linux/module.h" 1
># 10 "include/linux/module.h"
># 1 "include/linux/stat.h" 1
>
>
>
>
>
># 1 "include/asm/stat.h" 1
>
>
>
>
>
>
>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 int st_mtime_nsec;
>
> unsigned long st_ctime;
> unsigned long st_ctime_nsec;
>
> unsigned long long st_ino;
>};
># 93 "include/asm/stat.h"
>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;
>
>
>
>
>
>
>};
># 7 "include/linux/stat.h" 2
># 60 "include/linux/stat.h"
># 1 "include/linux/time.h" 1
>
>
>
>
>
>
>
># 1 "include/linux/seqlock.h" 1
># 32 "include/linux/seqlock.h"
>typedef struct {
> unsigned sequence;
> spinlock_t lock;
>} seqlock_t;
># 60 "include/linux/seqlock.h"
>static inline __attribute__((always_inline)) void write_seqlock(seqlock_t *sl)
>{
> _spin_lock(&sl->lock);
> ++sl->sequence;
> __asm__ __volatile__("": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void write_sequnlock(seqlock_t *sl)
>{
> __asm__ __volatile__("": : :"memory");
> sl->sequence++;
> do {__raw_spin_unlock(&(&sl->lock)->raw_lock); (void)0; } while (0);
>}
>
>static inline __attribute__((always_inline)) int write_tryseqlock(seqlock_t *sl)
>{
> int ret = (_spin_trylock(&sl->lock));
>
> if (ret) {
>  ++sl->sequence;
>  __asm__ __volatile__("": : :"memory");
> }
> return ret;
>}
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned read_seqbegin(const seqlock_t *sl)
>{
> unsigned ret = sl->sequence;
> __asm__ __volatile__("": : :"memory");
> return ret;
>}
># 101 "include/linux/seqlock.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) int read_seqretry(const seqlock_t *sl, unsigned iv)
>{
> __asm__ __volatile__("": : :"memory");
> return (iv & 1) | (sl->sequence ^ iv);
>}
># 115 "include/linux/seqlock.h"
>typedef struct seqcount {
> unsigned sequence;
>} seqcount_t;
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned read_seqcount_begin(const seqcount_t *s)
>{
> unsigned ret = s->sequence;
> __asm__ __volatile__("": : :"memory");
> return ret;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int read_seqcount_retry(const seqcount_t *s, unsigned iv)
>{
> __asm__ __volatile__("": : :"memory");
> return (iv & 1) | (s->sequence ^ iv);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void write_seqcount_begin(seqcount_t *s)
>{
> s->sequence++;
> __asm__ __volatile__("": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void write_seqcount_end(seqcount_t *s)
>{
> __asm__ __volatile__("": : :"memory");
> s->sequence++;
>}
># 9 "include/linux/time.h" 2
>
>
>
>
>struct timespec {
> time_t tv_sec;
> long tv_nsec;
>};
>
>
>struct timeval {
> time_t tv_sec;
> suseconds_t tv_usec;
>};
>
>struct timezone {
> int tz_minuteswest;
> int tz_dsttime;
>};
># 40 "include/linux/time.h"
>static inline __attribute__((always_inline)) int timespec_equal(const struct timespec *a,
>                                 const struct timespec *b)
>{
> return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
>{
> if (lhs->tv_sec < rhs->tv_sec)
>  return -1;
> if (lhs->tv_sec > rhs->tv_sec)
>  return 1;
> return lhs->tv_nsec - rhs->tv_nsec;
>}
>
>static inline __attribute__((always_inline)) int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
>{
> if (lhs->tv_sec < rhs->tv_sec)
>  return -1;
> if (lhs->tv_sec > rhs->tv_sec)
>  return 1;
> return lhs->tv_usec - rhs->tv_usec;
>}
>
>extern unsigned long mktime(const unsigned int year, const unsigned int mon,
>       const unsigned int day, const unsigned int hour,
>       const unsigned int min, const unsigned int sec);
>
>extern void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec);
>
>
>
>
>static inline __attribute__((always_inline)) struct timespec timespec_sub(struct timespec lhs,
>      struct timespec rhs)
>{
> struct timespec ts_delta;
> set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
>    lhs.tv_nsec - rhs.tv_nsec);
> return ts_delta;
>}
>
>
>
>
>
>
>
>extern struct timespec xtime;
>extern struct timespec wall_to_monotonic;
>extern seqlock_t xtime_lock;
>
>extern unsigned long read_persistent_clock(void);
>extern int update_persistent_clock(struct timespec now);
>extern int no_sync_cmos_clock __attribute__((__section__(".data.read_mostly")));
>void timekeeping_init(void);
>
>unsigned long get_seconds(void);
>struct timespec current_kernel_time(void);
>
>
>
>
>extern void do_gettimeofday(struct timeval *tv);
>extern int do_settimeofday(struct timespec *tv);
>extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
>
>extern long do_utimes(int dfd, char *filename, struct timespec *times, int flags);
>struct itimerval;
>extern int do_setitimer(int which, struct itimerval *value,
>   struct itimerval *ovalue);
>extern unsigned int alarm_setitimer(unsigned int seconds);
>extern int do_getitimer(int which, struct itimerval *value);
>extern void getnstimeofday(struct timespec *tv);
>extern void getboottime(struct timespec *ts);
>extern void monotonic_to_bootbased(struct timespec *ts);
>
>extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
>extern int timekeeping_is_continuous(void);
>extern void update_wall_time(void);
># 133 "include/linux/time.h"
>static inline __attribute__((always_inline)) s64 timespec_to_ns(const struct timespec *ts)
>{
> return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;
>}
># 145 "include/linux/time.h"
>static inline __attribute__((always_inline)) s64 timeval_to_ns(const struct timeval *tv)
>{
> return ((s64) tv->tv_sec * 1000000000L) +
>  tv->tv_usec * 1000L;
>}
>
>
>
>
>
>
>
>extern struct timespec ns_to_timespec(const s64 nsec);
>
>
>
>
>
>
>
>extern struct timeval ns_to_timeval(const s64 nsec);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void timespec_add_ns(struct timespec *a, u64 ns)
>{
> ns += a->tv_nsec;
> while(__builtin_expect(!!(ns >= 1000000000L), 0)) {
>  ns -= 1000000000L;
>  a->tv_sec++;
> }
> a->tv_nsec = ns;
>}
># 199 "include/linux/time.h"
>struct itimerspec {
> struct timespec it_interval;
> struct timespec it_value;
>};
>
>struct itimerval {
> struct timeval it_interval;
> struct timeval it_value;
>};
># 61 "include/linux/stat.h" 2
>
>struct kstat {
> u64 ino;
> dev_t dev;
> umode_t mode;
> unsigned int nlink;
> uid_t uid;
> gid_t gid;
> dev_t rdev;
> loff_t size;
> struct timespec atime;
> struct timespec mtime;
> struct timespec ctime;
> unsigned long blksize;
> unsigned long long blocks;
>};
># 11 "include/linux/module.h" 2
>
>
># 1 "include/linux/kmod.h" 1
># 31 "include/linux/kmod.h"
>extern int request_module(const char * name, ...) __attribute__ ((format (printf, 1, 2)));
>
>
>
>
>
>
>struct key;
>struct file;
>struct subprocess_info;
>
>
>struct subprocess_info *call_usermodehelper_setup(char *path,
>        char **argv, char **envp);
>
>
>void call_usermodehelper_setkeys(struct subprocess_info *info,
>     struct key *session_keyring);
>int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
>      struct file **filp);
>void call_usermodehelper_setcleanup(struct subprocess_info *info,
>        void (*cleanup)(char **argv, char **envp));
>
>enum umh_wait {
> UMH_NO_WAIT = -1,
> UMH_WAIT_EXEC = 0,
> UMH_WAIT_PROC = 1,
>};
>
>
>int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
>
>
>
>void call_usermodehelper_freeinfo(struct subprocess_info *info);
>
>static inline __attribute__((always_inline)) int
>call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
>{
> struct subprocess_info *info;
>
> info = call_usermodehelper_setup(path, argv, envp);
> if (info == ((void *)0))
>  return -12;
> return call_usermodehelper_exec(info, wait);
>}
>
>static inline __attribute__((always_inline)) int
>call_usermodehelper_keys(char *path, char **argv, char **envp,
>    struct key *session_keyring, enum umh_wait wait)
>{
> struct subprocess_info *info;
>
> info = call_usermodehelper_setup(path, argv, envp);
> if (info == ((void *)0))
>  return -12;
>
> call_usermodehelper_setkeys(info, session_keyring);
> return call_usermodehelper_exec(info, wait);
>}
>
>extern void usermodehelper_init(void);
>
>struct file;
>extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[],
>        struct file **filp);
># 14 "include/linux/module.h" 2
># 1 "include/linux/elf.h" 1
>
>
>
>
># 1 "include/linux/elf-em.h" 1
># 6 "include/linux/elf.h" 2
># 1 "include/asm/elf.h" 1
># 9 "include/asm/elf.h"
># 1 "include/asm/user.h" 1
>
>
># 1 "include/asm/user_32.h" 1
>
>
>
># 1 "include/asm/page.h" 1
># 5 "include/asm/user_32.h" 2
># 44 "include/asm/user_32.h"
>struct user_i387_struct {
> long cwd;
> long swd;
> long twd;
> long fip;
> long fcs;
> long foo;
> long fos;
> long st_space[20];
>};
>
>struct user_fxsr_struct {
> unsigned short cwd;
> unsigned short swd;
> unsigned short twd;
> unsigned short fop;
> long fip;
> long fcs;
> long foo;
> long fos;
> long mxcsr;
> long reserved;
> long st_space[32];
> long xmm_space[32];
> long padding[56];
>};
>
>
>
>
>
>
>
>struct user_regs_struct {
> long ebx, ecx, edx, esi, edi, ebp, eax;
> unsigned short ds, __ds, es, __es;
> unsigned short fs, __fs, gs, __gs;
> long orig_eax, eip;
> unsigned short cs, __cs;
> long eflags, esp;
> unsigned short ss, __ss;
>};
>
>
>
>
>struct user{
>
>
>  struct user_regs_struct regs;
>
>  int u_fpvalid;
>
>  struct user_i387_struct i387;
>
>  unsigned long int u_tsize;
>  unsigned long int u_dsize;
>  unsigned long int u_ssize;
>  unsigned long start_code;
>  unsigned long start_stack;
>
>
>
>  long int signal;
>  int reserved;
>  struct user_pt_regs * u_ar0;
>
>  struct user_i387_struct* u_fpstate;
>  unsigned long magic;
>  char u_comm[32];
>  int u_debugreg[8];
>};
># 4 "include/asm/user.h" 2
># 10 "include/asm/elf.h" 2
># 1 "include/asm/auxvec.h" 1
># 11 "include/asm/elf.h" 2
>
>typedef unsigned long elf_greg_t;
>
>
>typedef elf_greg_t elf_gregset_t[(sizeof (struct user_regs_struct) / sizeof(elf_greg_t))];
>
>typedef struct user_i387_struct elf_fpregset_t;
>
>
>
>typedef struct user_fxsr_struct elf_fpxregset_t;
># 78 "include/asm/elf.h"
># 1 "include/asm/processor.h" 1
># 79 "include/asm/elf.h" 2
># 1 "include/asm/system.h" 1
># 80 "include/asm/elf.h" 2
># 1 "include/asm/desc.h" 1
>
># 1 "include/asm/desc_32.h" 1
>
>
>
># 1 "include/asm/ldt.h" 1
># 20 "include/asm/ldt.h"
>struct user_desc {
> unsigned int entry_number;
> unsigned int base_addr;
> unsigned int limit;
> unsigned int seg_32bit:1;
> unsigned int contents:2;
> unsigned int read_exec_only:1;
> unsigned int limit_in_pages:1;
> unsigned int seg_not_present:1;
> unsigned int useable:1;
>
>
>
>};
># 5 "include/asm/desc_32.h" 2
># 1 "include/asm/segment.h" 1
># 6 "include/asm/desc_32.h" 2
>
>
>
>
># 1 "include/linux/smp.h" 1
># 11 "include/linux/smp.h"
>extern void cpu_idle(void);
>
>
>
>
>
>
>
># 1 "include/asm/smp.h" 1
>
># 1 "include/asm/smp_32.h" 1
># 15 "include/asm/smp_32.h"
># 1 "include/asm/mpspec.h" 1
>
># 1 "include/asm/mpspec_32.h" 1
>
>
>
>
># 1 "include/asm/mpspec_def.h" 1
># 19 "include/asm/mpspec_def.h"
>struct intel_mp_floating
>{
> char mpf_signature[4];
> unsigned long mpf_physptr;
> unsigned char mpf_length;
> unsigned char mpf_specification;
> unsigned char mpf_checksum;
> unsigned char mpf_feature1;
> unsigned char mpf_feature2;
> unsigned char mpf_feature3;
> unsigned char mpf_feature4;
> unsigned char mpf_feature5;
>};
>
>struct mp_config_table
>{
> char mpc_signature[4];
>
> unsigned short mpc_length;
> char mpc_spec;
> char mpc_checksum;
> char mpc_oem[8];
> char mpc_productid[12];
> unsigned long mpc_oemptr;
> unsigned short mpc_oemsize;
> unsigned short mpc_oemcount;
> unsigned long mpc_lapic;
> unsigned long reserved;
>};
># 58 "include/asm/mpspec_def.h"
>struct mpc_config_processor
>{
> unsigned char mpc_type;
> unsigned char mpc_apicid;
> unsigned char mpc_apicver;
> unsigned char mpc_cpuflag;
>
>
> unsigned long mpc_cpufeature;
>
>
>
> unsigned long mpc_featureflag;
> unsigned long mpc_reserved[2];
>};
>
>struct mpc_config_bus
>{
> unsigned char mpc_type;
> unsigned char mpc_busid;
> unsigned char mpc_bustype[6];
>};
># 101 "include/asm/mpspec_def.h"
>struct mpc_config_ioapic
>{
> unsigned char mpc_type;
> unsigned char mpc_apicid;
> unsigned char mpc_apicver;
> unsigned char mpc_flags;
>
> unsigned long mpc_apicaddr;
>};
>
>struct mpc_config_intsrc
>{
> unsigned char mpc_type;
> unsigned char mpc_irqtype;
> unsigned short mpc_irqflag;
> unsigned char mpc_srcbus;
> unsigned char mpc_srcbusirq;
> unsigned char mpc_dstapic;
> unsigned char mpc_dstirq;
>};
>
>enum mp_irq_source_types {
> mp_INT = 0,
> mp_NMI = 1,
> mp_SMI = 2,
> mp_ExtINT = 3
>};
>
>
>
>
>
>
>struct mpc_config_lintsrc
>{
> unsigned char mpc_type;
> unsigned char mpc_irqtype;
> unsigned short mpc_irqflag;
> unsigned char mpc_srcbusid;
> unsigned char mpc_srcbusirq;
> unsigned char mpc_destapic;
>
> unsigned char mpc_destapiclint;
>};
>
>struct mp_config_oemtable
>{
> char oem_signature[4];
>
> unsigned short oem_length;
> char oem_rev;
> char oem_checksum;
> char mpc_oem[8];
>};
>
>struct mpc_config_translation
>{
>        unsigned char mpc_type;
>        unsigned char trans_len;
>        unsigned char trans_type;
>        unsigned char trans_quad;
>        unsigned char trans_global;
>        unsigned char trans_local;
>        unsigned short trans_reserved;
>};
># 179 "include/asm/mpspec_def.h"
>enum mp_bustype {
> MP_BUS_ISA = 1,
> MP_BUS_EISA,
> MP_BUS_PCI,
> MP_BUS_MCA,
>};
># 6 "include/asm/mpspec_32.h" 2
># 1 "include/asm-x86/mach-generic/mach_mpspec.h" 1
># 7 "include/asm/mpspec_32.h" 2
>
>extern int mp_bus_id_to_type [260];
>extern int mp_bus_id_to_node [260];
>extern int mp_bus_id_to_local [260];
>extern int quad_local_to_mp_bus_id [32/4][4];
>extern int mp_bus_id_to_pci_bus [260];
>
>extern unsigned int def_to_bigsmp;
>extern unsigned int boot_cpu_physical_apicid;
>extern int smp_found_config;
>extern void find_smp_config (void);
>extern void get_smp_config (void);
>extern int nr_ioapics;
>extern int apic_version [256];
>extern int mp_irq_entries;
>extern struct mpc_config_intsrc mp_irqs [256];
>extern int mpc_default_type;
>extern unsigned long mp_lapic_addr;
>extern int pic_mode;
>
>
>extern void mp_register_lapic (u8 id, u8 enabled);
>extern void mp_register_lapic_address (u64 address);
>extern void mp_register_ioapic (u8 id, u32 address, u32 gsi_base);
>extern void mp_override_legacy_irq (u8 bus_irq, u8 polarity, u8 trigger, u32 gsi);
>extern void mp_config_acpi_legacy_irqs (void);
>extern int mp_register_gsi (u32 gsi, int edge_level, int active_high_low);
>
>
>
>
>struct physid_mask
>{
> unsigned long mask[(((256) + (32) - 1) / (32))];
>};
>
>typedef struct physid_mask physid_mask_t;
># 78 "include/asm/mpspec_32.h"
>extern physid_mask_t phys_cpu_present_map;
># 3 "include/asm/mpspec.h" 2
># 16 "include/asm/smp_32.h" 2
># 1 "include/asm/apic.h" 1
>
># 1 "include/asm/apic_32.h" 1
>
>
>
># 1 "include/linux/pm.h" 1
># 27 "include/linux/pm.h"
># 1 "include/asm/atomic.h" 1
># 28 "include/linux/pm.h" 2
># 1 "include/asm/errno.h" 1
># 29 "include/linux/pm.h" 2
>
>
>
>
>
>
>typedef int pm_request_t;
># 44 "include/linux/pm.h"
>typedef int pm_dev_t;
># 57 "include/linux/pm.h"
>enum
>{
> PM_SYS_UNKNOWN = 0x00000000,
> PM_SYS_KBC = 0x41d00303,
> PM_SYS_COM = 0x41d00500,
> PM_SYS_IRDA = 0x41d00510,
> PM_SYS_FDC = 0x41d00700,
> PM_SYS_VGA = 0x41d00900,
> PM_SYS_PCMCIA = 0x41d00e00,
>};
># 76 "include/linux/pm.h"
>struct pm_dev;
>
>typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);
>
>
>
>
>struct pm_dev
>{
> pm_dev_t type;
> unsigned long id;
> pm_callback callback;
> void *data;
>
> unsigned long flags;
> unsigned long state;
> unsigned long prev_state;
>
> struct list_head entry;
>};
>
>
>
>
>
>
>
>extern void (*pm_idle)(void);
>extern void (*pm_power_off)(void);
>extern void (*pm_power_off_prepare)(void);
>
>
>
>
>
>struct device;
>
>typedef struct pm_message {
> int event;
>} pm_message_t;
># 176 "include/linux/pm.h"
>struct dev_pm_info {
> pm_message_t power_state;
> unsigned can_wakeup:1;
>
> unsigned should_wakeup:1;
> struct list_head entry;
>
>};
>
>extern int device_power_down(pm_message_t state);
>extern void device_power_up(void);
>extern void device_resume(void);
>
>
>extern int device_suspend(pm_message_t state);
>extern int device_prepare_suspend(pm_message_t state);
>
>
>
>
>
>
>extern void __suspend_report_result(const char *function, void *fn, int ret);
># 210 "include/linux/pm.h"
>extern int (*platform_enable_wakeup)(struct device *dev, int is_on);
>
>static inline __attribute__((always_inline)) int call_platform_enable_wakeup(struct device *dev, int is_on)
>{
> if (platform_enable_wakeup)
>  return (*platform_enable_wakeup)(dev, is_on);
> return 0;
>}
># 5 "include/asm/apic_32.h" 2
># 1 "include/linux/delay.h" 1
># 10 "include/linux/delay.h"
>extern unsigned long loops_per_jiffy;
>
># 1 "include/asm/delay.h" 1
># 11 "include/asm/delay.h"
>extern void __bad_udelay(void);
>extern void __bad_ndelay(void);
>
>extern void __udelay(unsigned long usecs);
>extern void __ndelay(unsigned long nsecs);
>extern void __const_udelay(unsigned long usecs);
>extern void __delay(unsigned long loops);
># 29 "include/asm/delay.h"
>void use_tsc_delay(void);
># 13 "include/linux/delay.h" 2
># 38 "include/linux/delay.h"
>void calibrate_delay(void);
>void msleep(unsigned int msecs);
>unsigned long msleep_interruptible(unsigned int msecs);
>
>static inline __attribute__((always_inline)) void ssleep(unsigned int seconds)
>{
> msleep(seconds * 1000);
>}
># 6 "include/asm/apic_32.h" 2
># 1 "include/asm/fixmap.h" 1
>
># 1 "include/asm/fixmap_32.h" 1
># 22 "include/asm/fixmap_32.h"
>extern unsigned long __FIXADDR_TOP;
>
>
>
>
>
># 1 "include/asm/acpi.h" 1
>
>
>
>
># 1 "include/asm/acpi_32.h" 1
># 31 "include/asm/acpi_32.h"
># 1 "include/acpi/pdc_intel.h" 1
># 32 "include/asm/acpi_32.h" 2
>
># 1 "include/asm/system.h" 1
># 34 "include/asm/acpi_32.h" 2
># 59 "include/asm/acpi_32.h"
>int __acpi_acquire_global_lock(unsigned int *lock);
>int __acpi_release_global_lock(unsigned int *lock);
># 84 "include/asm/acpi_32.h"
>extern void early_quirks(void);
>
>
>extern int acpi_lapic;
>extern int acpi_ioapic;
>extern int acpi_noirq;
>extern int acpi_strict;
>extern int acpi_disabled;
>extern int acpi_ht;
>extern int acpi_pci_disabled;
>static inline __attribute__((always_inline)) void disable_acpi(void)
>{
> acpi_disabled = 1;
> acpi_ht = 0;
> acpi_pci_disabled = 1;
> acpi_noirq = 1;
>}
>
>
>
>
>extern int acpi_gsi_to_irq(u32 gsi, unsigned int *irq);
>
>
>extern int acpi_skip_timer_override;
>extern int acpi_use_timer_override;
>
>
>static inline __attribute__((always_inline)) void acpi_noirq_set(void) { acpi_noirq = 1; }
>static inline __attribute__((always_inline)) void acpi_disable_pci(void)
>{
> acpi_pci_disabled = 1;
> acpi_noirq_set();
>}
>extern int acpi_irq_balance_set(char *str);
>
>
>extern int acpi_save_state_mem(void);
>extern void acpi_restore_state_mem(void);
>
>extern unsigned long acpi_wakeup_address;
>
>
>extern void acpi_reserve_bootmem(void);
># 6 "include/asm/acpi.h" 2
>
>
>
>
># 1 "include/asm/processor.h" 1
># 11 "include/asm/acpi.h" 2
>
>
>
>
>static inline __attribute__((always_inline)) unsigned int acpi_processor_cstate_check(unsigned int max_cstate)
>{
>
>
>
>
>
>
> if (boot_cpu_data.x86 == 0x0F &&
>     boot_cpu_data.x86_vendor == 2 &&
>     boot_cpu_data.x86_model <= 0x05 &&
>     boot_cpu_data.x86_mask < 0x0A)
>  return 1;
> else
>  return max_cstate;
>}
># 29 "include/asm/fixmap_32.h" 2
># 1 "include/asm/apicdef.h" 1
>
># 1 "include/asm/apicdef_32.h" 1
># 125 "include/asm/apicdef_32.h"
>struct local_apic {
>
>        struct { unsigned int __reserved[4]; } __reserved_01;
>
>        struct { unsigned int __reserved[4]; } __reserved_02;
>
>        struct {
>  unsigned int __reserved_1 : 24,
>   phys_apic_id : 4,
>   __reserved_2 : 4;
>  unsigned int __reserved[3];
> } id;
>
>        const
> struct {
>  unsigned int version : 8,
>   __reserved_1 : 8,
>   max_lvt : 8,
>   __reserved_2 : 8;
>  unsigned int __reserved[3];
> } version;
>
>        struct { unsigned int __reserved[4]; } __reserved_03;
>
>        struct { unsigned int __reserved[4]; } __reserved_04;
>
>        struct { unsigned int __reserved[4]; } __reserved_05;
>
>        struct { unsigned int __reserved[4]; } __reserved_06;
>
>        struct {
>  unsigned int priority : 8,
>   __reserved_1 : 24;
>  unsigned int __reserved_2[3];
> } tpr;
>
>        const
> struct {
>  unsigned int priority : 8,
>   __reserved_1 : 24;
>  unsigned int __reserved_2[3];
> } apr;
>
>        const
> struct {
>  unsigned int priority : 8,
>   __reserved_1 : 24;
>  unsigned int __reserved_2[3];
> } ppr;
>
>        struct {
>  unsigned int eoi;
>  unsigned int __reserved[3];
> } eoi;
>
>        struct { unsigned int __reserved[4]; } __reserved_07;
>
>        struct {
>  unsigned int __reserved_1 : 24,
>   logical_dest : 8;
>  unsigned int __reserved_2[3];
> } ldr;
>
>        struct {
>  unsigned int __reserved_1 : 28,
>   model : 4;
>  unsigned int __reserved_2[3];
> } dfr;
>
>        struct {
>  unsigned int spurious_vector : 8,
>   apic_enabled : 1,
>   focus_cpu : 1,
>   __reserved_2 : 22;
>  unsigned int __reserved_3[3];
> } svr;
>
>        struct {
>         unsigned int bitfield;
>  unsigned int __reserved[3];
> } isr [8];
>
>        struct {
>         unsigned int bitfield;
>  unsigned int __reserved[3];
> } tmr [8];
>
>        struct {
>         unsigned int bitfield;
>  unsigned int __reserved[3];
> } irr [8];
>
>        union {
>  struct {
>   unsigned int send_cs_error : 1,
>    receive_cs_error : 1,
>    send_accept_error : 1,
>    receive_accept_error : 1,
>    __reserved_1 : 1,
>    send_illegal_vector : 1,
>    receive_illegal_vector : 1,
>    illegal_register_address : 1,
>    __reserved_2 : 24;
>   unsigned int __reserved_3[3];
>  } error_bits;
>  struct {
>   unsigned int errors;
>   unsigned int __reserved_3[3];
>  } all_errors;
> } esr;
>
>        struct { unsigned int __reserved[4]; } __reserved_08;
>
>        struct { unsigned int __reserved[4]; } __reserved_09;
>
>        struct { unsigned int __reserved[4]; } __reserved_10;
>
>        struct { unsigned int __reserved[4]; } __reserved_11;
>
>        struct { unsigned int __reserved[4]; } __reserved_12;
>
>        struct { unsigned int __reserved[4]; } __reserved_13;
>
>        struct { unsigned int __reserved[4]; } __reserved_14;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   destination_mode : 1,
>   delivery_status : 1,
>   __reserved_1 : 1,
>   level : 1,
>   trigger : 1,
>   __reserved_2 : 2,
>   shorthand : 2,
>   __reserved_3 : 12;
>  unsigned int __reserved_4[3];
> } icr1;
>
>        struct {
>  union {
>   unsigned int __reserved_1 : 24,
>    phys_dest : 4,
>    __reserved_2 : 4;
>   unsigned int __reserved_3 : 24,
>    logical_dest : 8;
>  } dest;
>  unsigned int __reserved_4[3];
> } icr2;
>
>        struct {
>  unsigned int vector : 8,
>   __reserved_1 : 4,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   timer_mode : 1,
>   __reserved_3 : 14;
>  unsigned int __reserved_4[3];
> } lvt_timer;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   __reserved_3 : 15;
>  unsigned int __reserved_4[3];
> } lvt_thermal;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   __reserved_3 : 15;
>  unsigned int __reserved_4[3];
> } lvt_pc;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   polarity : 1,
>   remote_irr : 1,
>   trigger : 1,
>   mask : 1,
>   __reserved_2 : 15;
>  unsigned int __reserved_3[3];
> } lvt_lint0;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   polarity : 1,
>   remote_irr : 1,
>   trigger : 1,
>   mask : 1,
>   __reserved_2 : 15;
>  unsigned int __reserved_3[3];
> } lvt_lint1;
>
>        struct {
>  unsigned int vector : 8,
>   __reserved_1 : 4,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   __reserved_3 : 15;
>  unsigned int __reserved_4[3];
> } lvt_error;
>
>        struct {
>  unsigned int initial_count;
>  unsigned int __reserved_2[3];
> } timer_icr;
>
>        const
> struct {
>  unsigned int curr_count;
>  unsigned int __reserved_2[3];
> } timer_ccr;
>
>        struct { unsigned int __reserved[4]; } __reserved_16;
>
>        struct { unsigned int __reserved[4]; } __reserved_17;
>
>        struct { unsigned int __reserved[4]; } __reserved_18;
>
>        struct { unsigned int __reserved[4]; } __reserved_19;
>
>        struct {
>  unsigned int divisor : 4,
>   __reserved_1 : 28;
>  unsigned int __reserved_2[3];
> } timer_dcr;
>
>        struct { unsigned int __reserved[4]; } __reserved_20;
>
>} __attribute__ ((packed));
># 3 "include/asm/apicdef.h" 2
># 30 "include/asm/fixmap_32.h" 2
># 1 "include/asm/page.h" 1
># 31 "include/asm/fixmap_32.h" 2
>
>
># 1 "include/asm/kmap_types.h" 1
># 10 "include/asm/kmap_types.h"
>enum km_type {
> KM_BOUNCE_READ,
> KM_SKB_SUNRPC_DATA,
> KM_SKB_DATA_SOFTIRQ,
> KM_USER0,
> KM_USER1,
> KM_BIO_SRC_IRQ,
> KM_BIO_DST_IRQ,
> KM_PTE0,
> KM_PTE1,
> KM_IRQ0,
> KM_IRQ1,
> KM_SOFTIRQ0,
> KM_SOFTIRQ1,
> KM_TYPE_NR
>};
># 34 "include/asm/fixmap_32.h" 2
># 54 "include/asm/fixmap_32.h"
>enum fixed_addresses {
> FIX_HOLE,
> FIX_VDSO,
> FIX_DBGP_BASE,
> FIX_EARLYCON_MEM_BASE,
>
> FIX_APIC_BASE,
>
>
> FIX_IO_APIC_BASE_0,
> FIX_IO_APIC_BASE_END = FIX_IO_APIC_BASE_0 + 64 -1,
># 76 "include/asm/fixmap_32.h"
> FIX_CYCLONE_TIMER,
>
>
> FIX_KMAP_BEGIN,
> FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*32)-1,
>
>
> FIX_ACPI_BEGIN,
> FIX_ACPI_END = FIX_ACPI_BEGIN + 4 - 1,
>
>
> FIX_PCIE_MCFG,
>
>
>
>
> __end_of_permanent_fixed_addresses,
>
>
> FIX_BTMAP_END = __end_of_permanent_fixed_addresses,
> FIX_BTMAP_BEGIN = FIX_BTMAP_END + 16 - 1,
> FIX_WP_TEST,
> __end_of_fixed_addresses
>};
>
>extern void __set_fixmap (enum fixed_addresses idx,
>     unsigned long phys, pgprot_t flags);
>extern void reserve_top_address(unsigned long reserve);
># 126 "include/asm/fixmap_32.h"
>extern void __this_fixmap_does_not_exist(void);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long fix_to_virt(const unsigned int idx)
>{
># 144 "include/asm/fixmap_32.h"
> if (idx >= __end_of_fixed_addresses)
>  __this_fixmap_does_not_exist();
>
>        return (((unsigned long)__FIXADDR_TOP) - ((idx) << 12));
>}
>
>static inline __attribute__((always_inline)) unsigned long virt_to_fix(const unsigned long vaddr)
>{
> do { if (__builtin_expect(!!(vaddr >= ((unsigned long)__FIXADDR_TOP) || vaddr < (((unsigned long)__FIXADDR_TOP) - (__end_of_permanent_fixed_addresses << 12))), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("include/asm/fixmap_32.h"), "i" (152), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
> return ((((unsigned long)__FIXADDR_TOP) - ((vaddr)&(~((1UL << 12)-1)))) >> 12);
>}
># 3 "include/asm/fixmap.h" 2
># 7 "include/asm/apic_32.h" 2
># 1 "include/asm/apicdef.h" 1
># 8 "include/asm/apic_32.h" 2
># 1 "include/asm/processor.h" 1
># 9 "include/asm/apic_32.h" 2
># 1 "include/asm/system.h" 1
># 10 "include/asm/apic_32.h" 2
># 20 "include/asm/apic_32.h"
>extern int apic_verbosity;
># 34 "include/asm/apic_32.h"
>extern void generic_apic_probe(void);
># 51 "include/asm/apic_32.h"
>static __inline __attribute__((always_inline)) __attribute__((regparm(3))) void native_apic_write(unsigned long reg,
>      unsigned long v)
>{
> *((volatile unsigned long *)((fix_to_virt(FIX_APIC_BASE))+reg)) = v;
>}
>
>static __inline __attribute__((always_inline)) __attribute__((regparm(3))) void native_apic_write_atomic(unsigned long reg,
>             unsigned long v)
>{
> ((__typeof__(*((volatile unsigned long *)((fix_to_virt(FIX_APIC_BASE))+reg))))__xchg((unsigned long)(v),((volatile unsigned long *)((fix_to_virt(FIX_APIC_BASE))+reg)),sizeof(*((volatile unsigned long *)((fix_to_virt(FIX_APIC_BASE))+reg)))));
>}
>
>static __inline __attribute__((always_inline)) __attribute__((regparm(3))) unsigned long native_apic_read(unsigned long reg)
>{
> return *((volatile unsigned long *)((fix_to_virt(FIX_APIC_BASE))+reg));
>}
>
>void apic_wait_icr_idle(void);
>unsigned long safe_apic_wait_icr_idle(void);
>int get_physical_broadcast(void);
># 82 "include/asm/apic_32.h"
>static inline __attribute__((always_inline)) void ack_APIC_irq(void)
>{
># 92 "include/asm/apic_32.h"
> native_apic_write((0xB0),(0));
>}
>
>extern int lapic_get_maxlvt(void);
>extern void clear_local_APIC(void);
>extern void connect_bsp_APIC (void);
>extern void disconnect_bsp_APIC (int virt_wire_setup);
>extern void disable_local_APIC (void);
>extern void lapic_shutdown (void);
>extern int verify_local_APIC (void);
>extern void cache_APIC_registers (void);
>extern void sync_Arb_IDs (void);
>extern void init_bsp_APIC (void);
>extern void setup_local_APIC (void);
>extern void init_apic_mappings (void);
>extern void smp_local_timer_interrupt (void);
>extern void setup_boot_APIC_clock (void);
>extern void setup_secondary_APIC_clock (void);
>extern int APIC_init_uniprocessor (void);
>
>extern void enable_NMI_through_LVT0 (void * dummy);
>
>
>
>extern int timer_over_8254;
>extern int local_apic_timer_c2_ok;
>
>extern int local_apic_timer_disabled;
># 3 "include/asm/apic.h" 2
># 17 "include/asm/smp_32.h" 2
>
># 1 "include/asm/io_apic.h" 1
>
># 1 "include/asm/io_apic_32.h" 1
>
>
>
>
># 1 "include/asm/mpspec.h" 1
># 6 "include/asm/io_apic_32.h" 2
># 1 "include/asm/apicdef.h" 1
># 7 "include/asm/io_apic_32.h" 2
># 17 "include/asm/io_apic_32.h"
>union IO_APIC_reg_00 {
> u32 raw;
> struct {
>  u32 __reserved_2 : 14,
>   LTS : 1,
>   delivery_type : 1,
>   __reserved_1 : 8,
>   ID : 8;
> } __attribute__ ((packed)) bits;
>};
>
>union IO_APIC_reg_01 {
> u32 raw;
> struct {
>  u32 version : 8,
>   __reserved_2 : 7,
>   PRQ : 1,
>   entries : 8,
>   __reserved_1 : 8;
> } __attribute__ ((packed)) bits;
>};
>
>union IO_APIC_reg_02 {
> u32 raw;
> struct {
>  u32 __reserved_2 : 24,
>   arbitration : 4,
>   __reserved_1 : 4;
> } __attribute__ ((packed)) bits;
>};
>
>union IO_APIC_reg_03 {
> u32 raw;
> struct {
>  u32 boot_DT : 1,
>   __reserved_1 : 31;
> } __attribute__ ((packed)) bits;
>};
>
>enum ioapic_irq_destination_types {
> dest_Fixed = 0,
> dest_LowestPrio = 1,
> dest_SMI = 2,
> dest__reserved_1 = 3,
> dest_NMI = 4,
> dest_INIT = 5,
> dest__reserved_2 = 6,
> dest_ExtINT = 7
>};
>
>struct IO_APIC_route_entry {
> __u32 vector : 8,
>  delivery_mode : 3,
>
>
>
>  dest_mode : 1,
>  delivery_status : 1,
>  polarity : 1,
>  irr : 1,
>  trigger : 1,
>  mask : 1,
>  __reserved_2 : 15;
>
> union { struct { __u32
>     __reserved_1 : 24,
>     physical_dest : 4,
>     __reserved_2 : 4;
>   } physical;
>
>   struct { __u32
>     __reserved_1 : 24,
>     logical_dest : 8;
>   } logical;
> } dest;
>
>} __attribute__ ((packed));
>
>
>
>
>
>
>extern int nr_ioapics;
>extern int nr_ioapic_registers[64];
>
>
>
>
>
>
>extern struct mpc_config_ioapic mp_ioapics[64];
>
>
>extern int mp_irq_entries;
>
>
>extern struct mpc_config_intsrc mp_irqs[256];
>
>
>extern int mpc_default_type;
>
>
>extern int sis_apic_bug;
>
>
>extern int skip_ioapic_setup;
>
>static inline __attribute__((always_inline)) void disable_ioapic_setup(void)
>{
> skip_ioapic_setup = 1;
>}
>
>static inline __attribute__((always_inline)) int ioapic_setup_disabled(void)
>{
> return skip_ioapic_setup;
>}
># 142 "include/asm/io_apic_32.h"
>extern int io_apic_get_unique_id (int ioapic, int apic_id);
>extern int io_apic_get_version (int ioapic);
>extern int io_apic_get_redir_entries (int ioapic);
>extern int io_apic_set_pci_routing (int ioapic, int pin, int irq, int edge_level, int active_high_low);
>extern int timer_uses_ioapic_pin_0;
>
>
>extern int (*ioapic_renumber_irq)(int ioapic, int irq);
># 3 "include/asm/io_apic.h" 2
># 19 "include/asm/smp_32.h" 2
># 30 "include/asm/smp_32.h"
>extern void smp_alloc_memory(void);
>extern int pic_mode;
>extern int smp_num_siblings;
>extern __typeof__(cpumask_t) per_cpu__cpu_sibling_map;
>extern __typeof__(cpumask_t) per_cpu__cpu_core_map;
>
>extern void (*mtrr_hook) (void);
>extern void zap_low_mappings (void);
>extern void lock_ipi_call_lock(void);
>extern void unlock_ipi_call_lock(void);
>
>
>extern u8 __attribute__ ((__section__ (".init.data"))) x86_cpu_to_apicid_init[];
>extern void *x86_cpu_to_apicid_ptr;
>extern __typeof__(u8) per_cpu__x86_cpu_to_apicid;
>
>
>
>extern void set_cpu_sibling_map(int cpu);
>
>
>extern void cpu_exit_clear(void);
>extern void cpu_uninit(void);
>extern void remove_siblinginfo(int cpu);
>
>
>struct smp_ops
>{
> void (*smp_prepare_boot_cpu)(void);
> void (*smp_prepare_cpus)(unsigned max_cpus);
> int (*cpu_up)(unsigned cpu);
> void (*smp_cpus_done)(unsigned max_cpus);
>
> void (*smp_send_stop)(void);
> void (*smp_send_reschedule)(int cpu);
> int (*smp_call_function_mask)(cpumask_t mask,
>          void (*func)(void *info), void *info,
>          int wait);
>};
>
>extern struct smp_ops smp_ops;
>
>static inline __attribute__((always_inline)) void smp_prepare_boot_cpu(void)
>{
> smp_ops.smp_prepare_boot_cpu();
>}
>static inline __attribute__((always_inline)) void smp_prepare_cpus(unsigned int max_cpus)
>{
> smp_ops.smp_prepare_cpus(max_cpus);
>}
>static inline __attribute__((always_inline)) int __cpu_up(unsigned int cpu)
>{
> return smp_ops.cpu_up(cpu);
>}
>static inline __attribute__((always_inline)) void smp_cpus_done(unsigned int max_cpus)
>{
> smp_ops.smp_cpus_done(max_cpus);
>}
>
>static inline __attribute__((always_inline)) void smp_send_stop(void)
>{
> smp_ops.smp_send_stop();
>}
>static inline __attribute__((always_inline)) void smp_send_reschedule(int cpu)
>{
> smp_ops.smp_send_reschedule(cpu);
>}
>static inline __attribute__((always_inline)) int smp_call_function_mask(cpumask_t mask,
>      void (*func) (void *info), void *info,
>      int wait)
>{
> return smp_ops.smp_call_function_mask(mask, func, info, wait);
>}
>
>void native_smp_prepare_boot_cpu(void);
>void native_smp_prepare_cpus(unsigned int max_cpus);
>int native_cpu_up(unsigned int cpunum);
>void native_smp_cpus_done(unsigned int max_cpus);
># 119 "include/asm/smp_32.h"
>extern __typeof__(int) per_cpu__cpu_number;
>
>
>extern cpumask_t cpu_callout_map;
>extern cpumask_t cpu_callin_map;
>extern cpumask_t cpu_possible_map;
>
>
>static inline __attribute__((always_inline)) int num_booting_cpus(void)
>{
> return __cpus_weight(&(cpu_callout_map), 32);
>}
>
>extern int safe_smp_processor_id(void);
>extern int __cpu_disable(void);
>extern void __cpu_die(unsigned int cpu);
>extern unsigned int num_processors;
>
>void smp_store_cpu_info(int id);
># 157 "include/asm/smp_32.h"
># 1 "include/asm-x86/mach-generic/mach_apicdef.h" 1
>
>
>
>
># 1 "include/asm/genapic.h" 1
>
># 1 "include/asm/genapic_32.h" 1
>
>
>
># 1 "include/asm/mpspec.h" 1
># 5 "include/asm/genapic_32.h" 2
># 17 "include/asm/genapic_32.h"
>struct mpc_config_translation;
>struct mpc_config_bus;
>struct mp_config_table;
>struct mpc_config_processor;
>
>struct genapic {
> char *name;
> int (*probe)(void);
>
> int (*apic_id_registered)(void);
> cpumask_t (*target_cpus)(void);
> int int_delivery_mode;
> int int_dest_mode;
> int ESR_DISABLE;
> int apic_destination_logical;
> unsigned long (*check_apicid_used)(physid_mask_t bitmap, int apicid);
> unsigned long (*check_apicid_present)(int apicid);
> int no_balance_irq;
> int no_ioapic_check;
> void (*init_apic_ldr)(void);
> physid_mask_t (*ioapic_phys_id_map)(physid_mask_t map);
>
> void (*setup_apic_routing)(void);
> int (*multi_timer_check)(int apic, int irq);
> int (*apicid_to_node)(int logical_apicid);
> int (*cpu_to_logical_apicid)(int cpu);
> int (*cpu_present_to_apicid)(int mps_cpu);
> physid_mask_t (*apicid_to_cpu_present)(int phys_apicid);
> int (*mpc_apic_id)(struct mpc_config_processor *m,
>      struct mpc_config_translation *t);
> void (*setup_portio_remap)(void);
> int (*check_phys_apicid_present)(int boot_cpu_physical_apicid);
> void (*enable_apic_mode)(void);
> u32 (*phys_pkg_id)(u32 cpuid_apic, int index_msb);
>
>
> void (*mpc_oem_bus_info)(struct mpc_config_bus *, char *,
>     struct mpc_config_translation *);
> void (*mpc_oem_pci_bus)(struct mpc_config_bus *,
>    struct mpc_config_translation *);
>
>
>
>
> int (*mps_oem_check)(struct mp_config_table *mpc, char *oem,
>         char *productid);
> int (*acpi_madt_oem_check)(char *oem_id, char *oem_table_id);
>
> unsigned (*get_apic_id)(unsigned long x);
> unsigned long apic_id_mask;
> unsigned int (*cpu_mask_to_apicid)(cpumask_t cpumask);
>
>
>
> void (*send_IPI_mask)(cpumask_t mask, int vector);
> void (*send_IPI_allbutself)(int vector);
> void (*send_IPI_all)(int vector);
>
>};
># 125 "include/asm/genapic_32.h"
>extern struct genapic *genapic;
># 3 "include/asm/genapic.h" 2
># 6 "include/asm-x86/mach-generic/mach_apicdef.h" 2
># 158 "include/asm/smp_32.h" 2
>static inline __attribute__((always_inline)) int hard_smp_processor_id(void)
>{
>
> return (genapic->get_apic_id)(*(unsigned long *)((fix_to_virt(FIX_APIC_BASE))+0x20));
>}
># 173 "include/asm/smp_32.h"
>extern u8 apicid_2_node[];
>
>
>static __inline __attribute__((always_inline)) int logical_smp_processor_id(void)
>{
>
> return (((*(unsigned long *)((fix_to_virt(FIX_APIC_BASE))+0xD0))>>24)&0xFF);
>}
># 3 "include/asm/smp.h" 2
># 20 "include/linux/smp.h" 2
># 29 "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);
>
>
>
>
>extern void smp_cpus_done(unsigned int max_cpus);
>
>
>
>
>int smp_call_function(void(*func)(void *info), void *info, int retry, int wait);
>
>int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
>    int retry, int wait);
>
>
>
>
>int on_each_cpu(void (*func) (void *info), void *info, int retry, int wait);
># 79 "include/linux/smp.h"
>void smp_prepare_boot_cpu(void);
># 142 "include/linux/smp.h"
>void smp_setup_processor_id(void);
># 11 "include/asm/desc_32.h" 2
># 1 "include/linux/percpu.h" 1
>
>
>
>
># 1 "include/linux/slab.h" 1
># 14 "include/linux/slab.h"
># 1 "include/linux/gfp.h" 1
>
>
>
># 1 "include/linux/mmzone.h" 1
># 13 "include/linux/mmzone.h"
># 1 "include/linux/numa.h" 1
># 14 "include/linux/mmzone.h" 2
>
>
># 1 "include/linux/nodemask.h" 1
># 88 "include/linux/nodemask.h"
>typedef struct { unsigned long bits[((((1 << 0)) + (32) - 1) / (32))]; } nodemask_t;
>extern nodemask_t _unused_nodemask_arg_;
>
>
>static inline __attribute__((always_inline)) void __node_set(int node, volatile nodemask_t *dstp)
>{
> set_bit(node, dstp->bits);
>}
>
>
>static inline __attribute__((always_inline)) void __node_clear(int node, volatile nodemask_t *dstp)
>{
> clear_bit(node, dstp->bits);
>}
>
>
>static inline __attribute__((always_inline)) void __nodes_setall(nodemask_t *dstp, int nbits)
>{
> bitmap_fill(dstp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) void __nodes_clear(nodemask_t *dstp, int nbits)
>{
> bitmap_zero(dstp->bits, nbits);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int __node_test_and_set(int node, nodemask_t *addr)
>{
> return test_and_set_bit(node, addr->bits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_and(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_or(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_xor(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_andnot(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_complement(nodemask_t *dstp,
>     const nodemask_t *srcp, int nbits)
>{
> bitmap_complement(dstp->bits, srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __nodes_equal(const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> return bitmap_equal(src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __nodes_intersects(const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> return bitmap_intersects(src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __nodes_subset(const nodemask_t *src1p,
>     const nodemask_t *src2p, int nbits)
>{
> return bitmap_subset(src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __nodes_empty(const nodemask_t *srcp, int nbits)
>{
> return bitmap_empty(srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __nodes_full(const nodemask_t *srcp, int nbits)
>{
> return bitmap_full(srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __nodes_weight(const nodemask_t *srcp, int nbits)
>{
> return bitmap_weight(srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_shift_right(nodemask_t *dstp,
>     const nodemask_t *srcp, int n, int nbits)
>{
> bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_shift_left(nodemask_t *dstp,
>     const nodemask_t *srcp, int n, int nbits)
>{
> bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int __first_node(const nodemask_t *srcp)
>{
> return ({ int __x = ((1 << 0)); int __y = (find_first_bit(srcp->bits, (1 << 0))); __x < __y ? __x: __y; });
>}
>
>
>static inline __attribute__((always_inline)) int __next_node(int n, const nodemask_t *srcp)
>{
> return ({ int __x = ((1 << 0)); int __y = (find_next_bit(srcp->bits, (1 << 0), n+1)); __x < __y ? __x: __y; });
>}
># 251 "include/linux/nodemask.h"
>static inline __attribute__((always_inline)) int __first_unset_node(const nodemask_t *maskp)
>{
> return ({ int __x = ((1 << 0)); int __y = (find_first_zero_bit(maskp->bits, (1 << 0))); __x < __y ? __x: __y; });
>
>}
># 285 "include/linux/nodemask.h"
>static inline __attribute__((always_inline)) int __nodemask_scnprintf(char *buf, int len,
>     const nodemask_t *srcp, int nbits)
>{
> return bitmap_scnprintf(buf, len, srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __nodemask_parse_user(const char *buf, int len,
>     nodemask_t *dstp, int nbits)
>{
> return bitmap_parse_user(buf, len, dstp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __nodelist_scnprintf(char *buf, int len,
>     const nodemask_t *srcp, int nbits)
>{
> return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
>}
>
>
>static inline __attribute__((always_inline)) int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
>{
> return bitmap_parselist(buf, dstp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) int __node_remap(int oldbit,
>  const nodemask_t *oldp, const nodemask_t *newp, int nbits)
>{
> return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
>}
>
>
>
>static inline __attribute__((always_inline)) void __nodes_remap(nodemask_t *dstp, const nodemask_t *srcp,
>  const nodemask_t *oldp, const nodemask_t *newp, int nbits)
>{
> bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
>}
># 343 "include/linux/nodemask.h"
>enum node_states {
> N_POSSIBLE,
> N_ONLINE,
> N_NORMAL_MEMORY,
>
> N_HIGH_MEMORY,
>
>
>
> N_CPU,
> NR_NODE_STATES
>};
>
>
>
>
>
>
>extern nodemask_t node_states[NR_NODE_STATES];
># 393 "include/linux/nodemask.h"
>static inline __attribute__((always_inline)) int node_state(int node, enum node_states state)
>{
> return node == 0;
>}
>
>static inline __attribute__((always_inline)) void node_set_state(int node, enum node_states state)
>{
>}
>
>static inline __attribute__((always_inline)) void node_clear_state(int node, enum node_states state)
>{
>}
>
>static inline __attribute__((always_inline)) int num_node_state(enum node_states state)
>{
> return 1;
>}
># 17 "include/linux/mmzone.h" 2
># 1 "include/linux/pageblock-flags.h" 1
># 33 "include/linux/pageblock-flags.h"
>enum pageblock_bits {
> PB_migrate, PB_migrate_end = (PB_migrate + 3) - 1,
> NR_PAGEBLOCK_BITS
>};
># 62 "include/linux/pageblock-flags.h"
>struct page;
>
>
>unsigned long get_pageblock_flags_group(struct page *page,
>     int start_bitidx, int end_bitidx);
>void set_pageblock_flags_group(struct page *page, unsigned long flags,
>     int start_bitidx, int end_bitidx);
># 18 "include/linux/mmzone.h" 2
># 1 "include/asm/atomic.h" 1
># 19 "include/linux/mmzone.h" 2
># 1 "include/asm/page.h" 1
># 20 "include/linux/mmzone.h" 2
># 48 "include/linux/mmzone.h"
>extern int page_group_by_mobility_disabled;
>
>static inline __attribute__((always_inline)) int get_pageblock_migratetype(struct page *page)
>{
> if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
>  return 0;
>
> return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
>}
>
>struct free_area {
> struct list_head free_list[5];
> unsigned long nr_free;
>};
>
>struct pglist_data;
># 72 "include/linux/mmzone.h"
>struct zone_padding {
> char x[0];
>} __attribute__((__aligned__(1 << ((7)))));
>
>
>
>
>
>enum zone_stat_item {
>
> NR_FREE_PAGES,
> NR_INACTIVE,
> NR_ACTIVE,
> NR_ANON_PAGES,
> NR_FILE_MAPPED,
>
> NR_FILE_PAGES,
> NR_FILE_DIRTY,
> NR_WRITEBACK,
>
> NR_SLAB_RECLAIMABLE,
> NR_SLAB_UNRECLAIMABLE,
> NR_PAGETABLE,
> NR_UNSTABLE_NFS,
> NR_BOUNCE,
> NR_VMSCAN_WRITE,
># 106 "include/linux/mmzone.h"
> NR_VM_ZONE_STAT_ITEMS };
>
>struct per_cpu_pages {
> int count;
> int high;
> int batch;
> struct list_head list;
>};
>
>struct per_cpu_pageset {
> struct per_cpu_pages pcp[2];
>
>
>
>
> s8 stat_threshold;
> s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
>
>} __attribute__((__aligned__((1 << (7)))));
>
>
>
>
>
>
>
>enum zone_type {
># 152 "include/linux/mmzone.h"
> ZONE_DMA,
># 167 "include/linux/mmzone.h"
> ZONE_NORMAL,
># 177 "include/linux/mmzone.h"
> ZONE_HIGHMEM,
>
> ZONE_MOVABLE,
> MAX_NR_ZONES
>};
># 214 "include/linux/mmzone.h"
>struct zone {
>
> unsigned long pages_min, pages_low, pages_high;
># 225 "include/linux/mmzone.h"
> unsigned long lowmem_reserve[MAX_NR_ZONES];
># 236 "include/linux/mmzone.h"
> struct per_cpu_pageset pageset[32];
>
>
>
>
> spinlock_t lock;
>
>
>
>
> struct free_area free_area[11];
>
>
>
>
>
>
> unsigned long *pageblock_flags;
>
>
>
> struct zone_padding _pad1_;
>
>
> spinlock_t lru_lock;
> struct list_head active_list;
> struct list_head inactive_list;
> unsigned long nr_scan_active;
> unsigned long nr_scan_inactive;
> unsigned long pages_scanned;
> unsigned long flags;
>
>
> atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
># 284 "include/linux/mmzone.h"
> int prev_priority;
>
>
> struct zone_padding _pad2_;
># 314 "include/linux/mmzone.h"
> wait_queue_head_t * wait_table;
> unsigned long wait_table_hash_nr_entries;
> unsigned long wait_table_bits;
>
>
>
>
> struct pglist_data *zone_pgdat;
>
> unsigned long zone_start_pfn;
># 335 "include/linux/mmzone.h"
> unsigned long spanned_pages;
> unsigned long present_pages;
>
>
>
>
> const char *name;
>} __attribute__((__aligned__(1 << ((7)))));
>
>typedef enum {
> ZONE_ALL_UNRECLAIMABLE,
> ZONE_RECLAIM_LOCKED,
> ZONE_OOM_LOCKED,
>} zone_flags_t;
>
>static inline __attribute__((always_inline)) void zone_set_flag(struct zone *zone, zone_flags_t flag)
>{
> set_bit(flag, &zone->flags);
>}
>
>static inline __attribute__((always_inline)) int zone_test_and_set_flag(struct zone *zone, zone_flags_t flag)
>{
> return test_and_set_bit(flag, &zone->flags);
>}
>
>static inline __attribute__((always_inline)) void zone_clear_flag(struct zone *zone, zone_flags_t flag)
>{
> clear_bit(flag, &zone->flags);
>}
>
>static inline __attribute__((always_inline)) int zone_is_all_unreclaimable(const struct zone *zone)
>{
> return (__builtin_constant_p(ZONE_ALL_UNRECLAIMABLE) ? constant_test_bit((ZONE_ALL_UNRECLAIMABLE),(&zone->flags)) : variable_test_bit((ZONE_ALL_UNRECLAIMABLE),(&zone->flags)));
>}
>
>static inline __attribute__((always_inline)) int zone_is_reclaim_locked(const struct zone *zone)
>{
> return (__builtin_constant_p(ZONE_RECLAIM_LOCKED) ? constant_test_bit((ZONE_RECLAIM_LOCKED),(&zone->flags)) : variable_test_bit((ZONE_RECLAIM_LOCKED),(&zone->flags)));
>}
>
>static inline __attribute__((always_inline)) int zone_is_oom_locked(const struct zone *zone)
>{
> return (__builtin_constant_p(ZONE_OOM_LOCKED) ? constant_test_bit((ZONE_OOM_LOCKED),(&zone->flags)) : variable_test_bit((ZONE_OOM_LOCKED),(&zone->flags)));
>}
># 468 "include/linux/mmzone.h"
>struct zonelist_cache;
># 481 "include/linux/mmzone.h"
>struct zonelist {
> struct zonelist_cache *zlcache_ptr;
> struct zone *zones[((1 << 0) * MAX_NR_ZONES) + 1];
>
>
>
>};
># 501 "include/linux/mmzone.h"
>static inline __attribute__((always_inline)) int alloc_should_filter_zonelist(struct zonelist *zonelist)
>{
> return 0;
>}
>
>
>
>struct node_active_region {
> unsigned long start_pfn;
> unsigned long end_pfn;
> int nid;
>};
>
>
>
>
>extern struct page *mem_map;
># 531 "include/linux/mmzone.h"
>struct bootmem_data;
>typedef struct pglist_data {
> struct zone node_zones[MAX_NR_ZONES];
> struct zonelist node_zonelists[MAX_NR_ZONES];
> int nr_zones;
>
> struct page *node_mem_map;
>
> struct bootmem_data *bdata;
># 550 "include/linux/mmzone.h"
> unsigned long node_start_pfn;
> unsigned long node_present_pages;
> unsigned long node_spanned_pages;
>
> int node_id;
> wait_queue_head_t kswapd_wait;
> struct task_struct *kswapd;
> int kswapd_max_order;
>} pg_data_t;
># 569 "include/linux/mmzone.h"
># 1 "include/linux/memory_hotplug.h" 1
>
>
>
># 1 "include/linux/mmzone.h" 1
># 5 "include/linux/memory_hotplug.h" 2
>
># 1 "include/linux/notifier.h" 1
># 13 "include/linux/notifier.h"
># 1 "include/linux/mutex.h" 1
># 18 "include/linux/mutex.h"
># 1 "include/asm/atomic.h" 1
># 19 "include/linux/mutex.h" 2
># 48 "include/linux/mutex.h"
>struct mutex {
>
> atomic_t count;
> spinlock_t wait_lock;
> struct list_head wait_list;
># 61 "include/linux/mutex.h"
>};
>
>
>
>
>
>struct mutex_waiter {
> struct list_head list;
> struct task_struct *task;
>
>
>
>
>};
># 106 "include/linux/mutex.h"
>extern void __mutex_init(struct mutex *lock, const char *name,
>    struct lock_class_key *key);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int __attribute__((regparm(3))) mutex_is_locked(struct mutex *lock)
>{
> return ((&lock->count)->counter) != 1;
>}
># 132 "include/linux/mutex.h"
>extern void __attribute__((regparm(3))) mutex_lock(struct mutex *lock);
>extern int __attribute__((warn_unused_result)) __attribute__((regparm(3))) mutex_lock_interruptible(struct mutex *lock);
># 143 "include/linux/mutex.h"
>extern int __attribute__((regparm(3))) mutex_trylock(struct mutex *lock);
>extern void __attribute__((regparm(3))) mutex_unlock(struct mutex *lock);
># 14 "include/linux/notifier.h" 2
># 1 "include/linux/rwsem.h" 1
># 16 "include/linux/rwsem.h"
># 1 "include/asm/system.h" 1
># 17 "include/linux/rwsem.h" 2
># 1 "include/asm/atomic.h" 1
># 18 "include/linux/rwsem.h" 2
>
>struct rw_semaphore;
>
>
>
>
># 1 "include/asm/rwsem.h" 1
># 45 "include/asm/rwsem.h"
>struct rwsem_waiter;
>
>extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *sem) __attribute__((regparm(3)));
>extern struct rw_semaphore *rwsem_down_write_failed(struct rw_semaphore *sem) __attribute__((regparm(3)));
>extern struct rw_semaphore *rwsem_wake(struct rw_semaphore *) __attribute__((regparm(3)));
>extern struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem) __attribute__((regparm(3)));
>
>
>
>
>struct rw_semaphore {
> signed long count;
>
>
>
>
>
>
> spinlock_t wait_lock;
> struct list_head wait_list;
>
>
>
>};
># 84 "include/asm/rwsem.h"
>extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
>    struct lock_class_key *key);
># 97 "include/asm/rwsem.h"
>static inline __attribute__((always_inline)) void __down_read(struct rw_semaphore *sem)
>{
> __asm__ __volatile__(
>  "# beginning down_read\n\t"
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "  incl      (%%eax)\n\t"
>  "  jns        1f\n"
>  "  call call_rwsem_down_read_failed\n"
>  "1:\n\t"
>  "# ending down_read\n\t"
>  : "+m" (sem->count)
>  : "a" (sem)
>  : "memory", "cc");
>}
>
>
>
>
>static inline __attribute__((always_inline)) int __down_read_trylock(struct rw_semaphore *sem)
>{
> __s32 result, tmp;
> __asm__ __volatile__(
>  "# beginning __down_read_trylock\n\t"
>  "  movl      %0,%1\n\t"
>  "1:\n\t"
>  "  movl	     %1,%2\n\t"
>  "  addl      %3,%2\n\t"
>  "  jle	     2f\n\t"
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "  cmpxchgl  %2,%0\n\t"
>  "  jnz	     1b\n\t"
>  "2:\n\t"
>  "# ending __down_read_trylock\n\t"
>  : "+m" (sem->count), "=&a" (result), "=&r" (tmp)
>  : "i" (0x00000001)
>  : "memory", "cc");
> return result>=0 ? 1 : 0;
>}
>
>
>
>
>static inline __attribute__((always_inline)) void __down_write_nested(struct rw_semaphore *sem, int subclass)
>{
> int tmp;
>
> tmp = ((-0x00010000) + 0x00000001);
> __asm__ __volatile__(
>  "# beginning down_write\n\t"
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "  xadd      %%edx,(%%eax)\n\t"
>  "  testl     %%edx,%%edx\n\t"
>  "  jz        1f\n"
>  "  call call_rwsem_down_write_failed\n"
>  "1:\n"
>  "# ending down_write"
>  : "+m" (sem->count), "=d" (tmp)
>  : "a" (sem), "1" (tmp)
>  : "memory", "cc");
>}
>
>static inline __attribute__((always_inline)) void __down_write(struct rw_semaphore *sem)
>{
> __down_write_nested(sem, 0);
>}
>
>
>
>
>static inline __attribute__((always_inline)) int __down_write_trylock(struct rw_semaphore *sem)
>{
> signed long ret = ((__typeof__(*(&sem->count)))__cmpxchg((&sem->count),(unsigned long)(0x00000000), (unsigned long)(((-0x00010000) + 0x00000001)),sizeof(*(&sem->count))));
>
>
> if (ret == 0x00000000)
>  return 1;
> return 0;
>}
>
>
>
>
>static inline __attribute__((always_inline)) void __up_read(struct rw_semaphore *sem)
>{
> __s32 tmp = -0x00000001;
> __asm__ __volatile__(
>  "# beginning __up_read\n\t"
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "  xadd      %%edx,(%%eax)\n\t"
>  "  jns        1f\n\t"
>  "  call call_rwsem_wake\n"
>  "1:\n"
>  "# ending __up_read\n"
>  : "+m" (sem->count), "=d" (tmp)
>  : "a" (sem), "1" (tmp)
>  : "memory", "cc");
>}
>
>
>
>
>static inline __attribute__((always_inline)) void __up_write(struct rw_semaphore *sem)
>{
> __asm__ __volatile__(
>  "# beginning __up_write\n\t"
>  "  movl      %2,%%edx\n\t"
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "  xaddl     %%edx,(%%eax)\n\t"
>  "  jz       1f\n"
>  "  call call_rwsem_wake\n"
>  "1:\n\t"
>  "# ending __up_write\n"
>  : "+m" (sem->count)
>  : "a" (sem), "i" (-((-0x00010000) + 0x00000001))
>  : "memory", "cc", "edx");
>}
>
>
>
>
>static inline __attribute__((always_inline)) void __downgrade_write(struct rw_semaphore *sem)
>{
> __asm__ __volatile__(
>  "# beginning __downgrade_write\n\t"
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "  addl      %2,(%%eax)\n\t"
>  "  jns       1f\n\t"
>  "  call call_rwsem_downgrade_wake\n"
>  "1:\n\t"
>  "# ending __downgrade_write\n"
>  : "+m" (sem->count)
>  : "a" (sem), "i" (-(-0x00010000))
>  : "memory", "cc");
>}
>
>
>
>
>static inline __attribute__((always_inline)) void rwsem_atomic_add(int delta, struct rw_semaphore *sem)
>{
> __asm__ __volatile__(
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "addl %1,%0"
>  : "+m" (sem->count)
>  : "ir" (delta));
>}
>
>
>
>
>static inline __attribute__((always_inline)) int rwsem_atomic_update(int delta, struct rw_semaphore *sem)
>{
> int tmp = delta;
>
> __asm__ __volatile__(
>".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "xadd %0,%1"
>  : "+r" (tmp), "+m" (sem->count)
>  : : "memory");
>
> return tmp+delta;
>}
>
>static inline __attribute__((always_inline)) int rwsem_is_locked(struct rw_semaphore *sem)
>{
> return (sem->count != 0);
>}
># 25 "include/linux/rwsem.h" 2
>
>
>
>
>
>extern void down_read(struct rw_semaphore *sem);
>
>
>
>
>extern int down_read_trylock(struct rw_semaphore *sem);
>
>
>
>
>extern void down_write(struct rw_semaphore *sem);
>
>
>
>
>extern int down_write_trylock(struct rw_semaphore *sem);
>
>
>
>
>extern void up_read(struct rw_semaphore *sem);
>
>
>
>
>extern void up_write(struct rw_semaphore *sem);
>
>
>
>
>extern void downgrade_write(struct rw_semaphore *sem);
># 15 "include/linux/notifier.h" 2
># 1 "include/linux/srcu.h" 1
># 30 "include/linux/srcu.h"
>struct srcu_struct_array {
> int c[2];
>};
>
>struct srcu_struct {
> int completed;
> struct srcu_struct_array *per_cpu_ref;
> struct mutex mutex;
>};
>
>
>
>
>
>
>
>int init_srcu_struct(struct srcu_struct *sp);
>void cleanup_srcu_struct(struct srcu_struct *sp);
>int srcu_read_lock(struct srcu_struct *sp) ;
>void srcu_read_unlock(struct srcu_struct *sp, int idx) ;
>void synchronize_srcu(struct srcu_struct *sp);
>long srcu_batches_completed(struct srcu_struct *sp);
># 16 "include/linux/notifier.h" 2
># 50 "include/linux/notifier.h"
>struct notifier_block {
> int (*notifier_call)(struct notifier_block *, unsigned long, void *);
> struct notifier_block *next;
> int priority;
>};
>
>struct atomic_notifier_head {
> spinlock_t lock;
> struct notifier_block *head;
>};
>
>struct blocking_notifier_head {
> struct rw_semaphore rwsem;
> struct notifier_block *head;
>};
>
>struct raw_notifier_head {
> struct notifier_block *head;
>};
>
>struct srcu_notifier_head {
> struct mutex mutex;
> struct srcu_struct srcu;
> struct notifier_block *head;
>};
># 89 "include/linux/notifier.h"
>extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
># 115 "include/linux/notifier.h"
>extern int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
>  struct notifier_block *nb);
>extern int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
>  struct notifier_block *nb);
>extern int raw_notifier_chain_register(struct raw_notifier_head *nh,
>  struct notifier_block *nb);
>extern int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
>  struct notifier_block *nb);
>
>extern int 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);
># 161 "include/linux/notifier.h"
>static inline __attribute__((always_inline)) int notifier_from_errno(int err)
>{
> return 0x8000 | (0x0001 - err);
>}
>
>
>static inline __attribute__((always_inline)) int notifier_to_errno(int ret)
>{
> ret &= ~0x8000;
> return ret > 0x0001 ? 0x0001 - ret : 0;
>}
># 243 "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;
># 149 "include/linux/memory_hotplug.h"
>static inline __attribute__((always_inline)) void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
>static inline __attribute__((always_inline)) void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
>static inline __attribute__((always_inline)) void pgdat_resize_init(struct pglist_data *pgdat) {}
>
>static inline __attribute__((always_inline)) unsigned zone_span_seqbegin(struct zone *zone)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int zone_span_seqretry(struct zone *zone, unsigned iv)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) void zone_span_writelock(struct zone *zone) {}
>static inline __attribute__((always_inline)) void zone_span_writeunlock(struct zone *zone) {}
>static inline __attribute__((always_inline)) void zone_seqlock_init(struct zone *zone) {}
>
>static inline __attribute__((always_inline)) int mhp_notimplemented(const char *func)
>{
> printk("<4>" "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n", func);
> dump_stack();
> return -38;
>}
>
>
>
>extern int add_memory(int nid, u64 start, u64 size);
>extern int arch_add_memory(int nid, u64 start, u64 size);
>extern int remove_memory(u64 start, u64 size);
>extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
>        int nr_pages);
># 570 "include/linux/mmzone.h" 2
>
>void get_zone_counts(unsigned long *active, unsigned long *inactive,
>   unsigned long *free);
>void build_all_zonelists(void);
>void wakeup_kswapd(struct zone *zone, int order);
>int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
>  int classzone_idx, int alloc_flags);
>enum memmap_context {
> MEMMAP_EARLY,
> MEMMAP_HOTPLUG,
>};
>extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
>         unsigned long size,
>         enum memmap_context context);
>
>
>
>
>static inline __attribute__((always_inline)) void memory_present(int nid, unsigned long start, unsigned long end) {}
># 600 "include/linux/mmzone.h"
>static inline __attribute__((always_inline)) int populated_zone(struct zone *zone)
>{
> return (!!zone->present_pages);
>}
>
>extern int movable_zone;
>
>static inline __attribute__((always_inline)) int zone_movable_is_highmem(void)
>{
>
> return movable_zone == ZONE_HIGHMEM;
>
>
>
>}
>
>static inline __attribute__((always_inline)) int is_highmem_idx(enum zone_type idx)
>{
>
> return (idx == ZONE_HIGHMEM ||
>  (idx == ZONE_MOVABLE && zone_movable_is_highmem()));
>
>
>
>}
>
>static inline __attribute__((always_inline)) int is_normal_idx(enum zone_type idx)
>{
> return (idx == ZONE_NORMAL);
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int is_highmem(struct zone *zone)
>{
>
> int zone_idx = zone - zone->zone_pgdat->node_zones;
> return zone_idx == ZONE_HIGHMEM ||
>  (zone_idx == ZONE_MOVABLE && zone_movable_is_highmem());
>
>
>
>}
>
>static inline __attribute__((always_inline)) int is_normal(struct zone *zone)
>{
> return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
>}
>
>static inline __attribute__((always_inline)) int is_dma32(struct zone *zone)
>{
>
>
>
> return 0;
>
>}
>
>static inline __attribute__((always_inline)) int is_dma(struct zone *zone)
>{
>
> return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
>
>
>
>}
>
>
>struct ctl_table;
>struct file;
>int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *,
>     void *, size_t *, loff_t *);
>extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
>int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
>     void *, size_t *, loff_t *);
>int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
>     void *, size_t *, loff_t *);
>int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
>   struct file *, void *, size_t *, loff_t *);
>int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
>   struct file *, void *, size_t *, loff_t *);
>
>extern int numa_zonelist_order_handler(struct ctl_table *, int,
>   struct file *, void *, size_t *, loff_t *);
>extern char numa_zonelist_order[];
>
>
># 1 "include/linux/topology.h" 1
># 34 "include/linux/topology.h"
># 1 "include/asm/topology.h" 1
>
># 1 "include/asm/topology_32.h" 1
># 110 "include/asm/topology_32.h"
># 1 "include/asm-generic/topology.h" 1
># 111 "include/asm/topology_32.h" 2
>
>
>
>extern cpumask_t cpu_coregroup_map(int cpu);
># 3 "include/asm/topology.h" 2
># 35 "include/linux/topology.h" 2
># 692 "include/linux/mmzone.h" 2
>
>
>
>
>
>
>
>extern struct pglist_data contig_page_data;
># 710 "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);
># 927 "include/linux/mmzone.h"
>void memory_present(int nid, unsigned long start, unsigned long end);
>unsigned long __attribute__ ((__section__ (".init.text"))) node_memmap_size_bytes(int, unsigned long, unsigned long);
># 5 "include/linux/gfp.h" 2
>
>
>
>struct vm_area_struct;
># 108 "include/linux/gfp.h"
>static inline __attribute__((always_inline)) int allocflags_to_migratetype(gfp_t gfp_flags)
>{
> ({ int __ret_warn_on = !!((gfp_flags & ((( gfp_t)0x80000u)|(( gfp_t)0x100000u))) == ((( gfp_t)0x80000u)|(( gfp_t)0x100000u))); if (__builtin_expect(!!(__ret_warn_on), 0)) { printk("WARNING: at %s:%d %s()\n", "include/linux/gfp.h", 110, (__func__)); dump_stack(); } __builtin_expect(!!(__ret_warn_on), 0); });
>
> if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
>  return 0;
>
>
> return (((gfp_flags & (( gfp_t)0x100000u)) != 0) << 1) |
>  ((gfp_flags & (( gfp_t)0x80000u)) != 0);
>}
>
>static inline __attribute__((always_inline)) enum zone_type gfp_zone(gfp_t flags)
>{
> int base = 0;
>
>
>
>
>
>
>
> if (flags & (( gfp_t)0x01u))
>  return base + ZONE_DMA;
>
>
>
>
>
> if ((flags & ((( gfp_t)0x02u) | (( gfp_t)0x100000u))) ==
>   ((( gfp_t)0x02u) | (( gfp_t)0x100000u)))
>  return base + ZONE_MOVABLE;
>
> if (flags & (( gfp_t)0x02u))
>  return base + ZONE_HIGHMEM;
>
> return base + ZONE_NORMAL;
>}
>
>static inline __attribute__((always_inline)) gfp_t set_migrateflags(gfp_t gfp, gfp_t migrate_flags)
>{
> do { if (__builtin_expect(!!((gfp & ((( gfp_t)0x80000u)|(( gfp_t)0x100000u))) == ((( gfp_t)0x80000u)|(( gfp_t)0x100000u))), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("include/linux/gfp.h"), "i" (149), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
> return (gfp & ~(((( gfp_t)0x80000u)|(( gfp_t)0x100000u)))) | migrate_flags;
>}
># 169 "include/linux/gfp.h"
>static inline __attribute__((always_inline)) void arch_free_page(struct page *page, int order) { }
>
>
>static inline __attribute__((always_inline)) void arch_alloc_page(struct page *page, int order) { }
>
>
>extern struct page *
>__alloc_pages(gfp_t, unsigned int, struct zonelist *) __attribute__((regparm(3)));
>
>static inline __attribute__((always_inline)) struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
>      unsigned int order)
>{
> if (__builtin_expect(!!(order >= 11), 0))
>  return ((void *)0);
>
>
> if (nid < 0)
>  nid = ((0));
>
> return __alloc_pages(gfp_mask, order,
>  (&contig_page_data)->node_zonelists + gfp_zone(gfp_mask));
>}
># 212 "include/linux/gfp.h"
>extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order) __attribute__((regparm(3)));
>extern unsigned long get_zeroed_page(gfp_t gfp_mask) __attribute__((regparm(3)));
>
>
>
>
>
>
>
>extern void __free_pages(struct page *page, unsigned int order) __attribute__((regparm(3)));
>extern void free_pages(unsigned long addr, unsigned int order) __attribute__((regparm(3)));
>extern void free_hot_page(struct page *page) __attribute__((regparm(3)));
>extern void free_cold_page(struct page *page) __attribute__((regparm(3)));
>
>
>
>
>void page_alloc_init(void);
>void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
># 15 "include/linux/slab.h" 2
># 51 "include/linux/slab.h"
>void __attribute__ ((__section__ (".init.text"))) kmem_cache_init(void);
>int slab_is_available(void);
>
>struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
>   unsigned long,
>   void (*)(struct kmem_cache *, void *));
>void kmem_cache_destroy(struct kmem_cache *);
>int kmem_cache_shrink(struct kmem_cache *);
>void kmem_cache_free(struct kmem_cache *, void *);
>unsigned int kmem_cache_size(struct kmem_cache *);
>const char *kmem_cache_name(struct kmem_cache *);
>int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
># 94 "include/linux/slab.h"
>void * __attribute__((warn_unused_result)) krealloc(const void *, size_t, gfp_t);
>void kfree(const void *);
>size_t ksize(const void *);
># 122 "include/linux/slab.h"
># 1 "include/linux/slab_def.h" 1
># 14 "include/linux/slab_def.h"
># 1 "include/asm/page.h" 1
># 15 "include/linux/slab_def.h" 2
>
>
>
>
>struct cache_sizes {
> size_t cs_size;
> struct kmem_cache *cs_cachep;
>
> struct kmem_cache *cs_dmacachep;
>
>};
>extern struct cache_sizes malloc_sizes[];
>
>void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
>void *__kmalloc(size_t size, gfp_t flags);
>
>static inline __attribute__((always_inline)) void *kmalloc(size_t size, gfp_t flags)
>{
> if (__builtin_constant_p(size)) {
>  int i = 0;
>
>  if (!size)
>   return ((void *)16);
>
>
>
>
>
>
># 1 "include/linux/kmalloc_sizes.h" 1
>
> if (size <= 32) goto found; else i++;
>
> if (size <= 64) goto found; else i++;
>
>
>
> if (size <= 128) goto found; else i++;
>
>
>
> if (size <= 256) goto found; else i++;
> if (size <= 512) goto found; else i++;
> if (size <= 1024) goto found; else i++;
> if (size <= 2048) goto found; else i++;
> if (size <= 4096) goto found; else i++;
> if (size <= 8192) goto found; else i++;
> if (size <= 16384) goto found; else i++;
> if (size <= 32768) goto found; else i++;
> if (size <= 65536) goto found; else i++;
> if (size <= 131072) goto found; else i++;
>
> if (size <= 262144) goto found; else i++;
>
>
> if (size <= 524288) goto found; else i++;
>
>
> if (size <= 1048576) goto found; else i++;
>
>
> if (size <= 2097152) goto found; else i++;
>
>
> if (size <= 4194304) goto found; else i++;
># 45 "include/linux/slab_def.h" 2
>
>  {
>   extern void __you_cannot_kmalloc_that_much(void);
>   __you_cannot_kmalloc_that_much();
>  }
>found:
>
>  if (flags & (( gfp_t)0x01u))
>   return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
>      flags);
>
>  return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
> }
> return __kmalloc(size, flags);
>}
># 98 "include/linux/slab_def.h"
>extern const struct seq_operations slabinfo_op;
>ssize_t slabinfo_write(struct file *, const char *, size_t, loff_t *);
># 123 "include/linux/slab.h" 2
># 176 "include/linux/slab.h"
>static inline __attribute__((always_inline)) void *kcalloc(size_t n, size_t size, gfp_t flags)
>{
> if (n != 0 && size > (~0UL) / n)
>  return ((void *)0);
> return __kmalloc(n * size, flags | (( gfp_t)0x8000u));
>}
># 194 "include/linux/slab.h"
>static inline __attribute__((always_inline)) void *kmalloc_node(size_t size, gfp_t flags, int node)
>{
> return kmalloc(size, flags);
>}
>
>static inline __attribute__((always_inline)) void *__kmalloc_node(size_t size, gfp_t flags, int node)
>{
> return __kmalloc(size, flags);
>}
>
>void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
>
>static inline __attribute__((always_inline)) void *kmem_cache_alloc_node(struct kmem_cache *cachep,
>     gfp_t flags, int node)
>{
> return kmem_cache_alloc(cachep, flags);
>}
># 259 "include/linux/slab.h"
>static inline __attribute__((always_inline)) void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
>{
> return kmem_cache_alloc(k, flags | (( gfp_t)0x8000u));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void *kzalloc(size_t size, gfp_t flags)
>{
> return kmalloc(size, flags | (( gfp_t)0x8000u));
>}
># 6 "include/linux/percpu.h" 2
>
>
>
>
># 1 "include/asm/percpu.h" 1
># 11 "include/linux/percpu.h" 2
># 36 "include/linux/percpu.h"
>struct percpu_data {
> void *ptrs[32];
>};
># 52 "include/linux/percpu.h"
>extern void *percpu_populate(void *__pdata, size_t size, gfp_t gfp, int cpu);
>extern void percpu_depopulate(void *__pdata, int cpu);
>extern int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
>      cpumask_t *mask);
>extern void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask);
>extern void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask);
>extern void percpu_free(void *__pdata);
># 12 "include/asm/desc_32.h" 2
>
># 1 "include/asm/mmu.h" 1
># 13 "include/asm/mmu.h"
>typedef struct {
> void *ldt;
>
>
>
> int size;
> struct mutex lock;
> void *vdso;
>} mm_context_t;
># 14 "include/asm/desc_32.h" 2
>
>struct Xgt_desc_struct {
> unsigned short size;
> unsigned long address __attribute__((packed));
> unsigned short pad;
>} __attribute__ ((packed));
>
>struct gdt_page
>{
> struct desc_struct gdt[32];
>} __attribute__((aligned((1UL << 12))));
>extern __typeof__(struct gdt_page) per_cpu__gdt_page;
>
>static inline __attribute__((always_inline)) struct desc_struct *get_cpu_gdt_table(unsigned int cpu)
>{
> return (*({ extern int simple_indentifier_gdt_page(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__gdt_page)); (typeof(&per_cpu__gdt_page)) (__ptr + (__per_cpu_offset[cpu])); }); })).gdt;
>}
>
>extern struct Xgt_desc_struct idt_descr;
>extern struct desc_struct idt_table[];
>extern void set_intr_gate(unsigned int irq, void * addr);
>
>static inline __attribute__((always_inline)) void pack_descriptor(__u32 *a, __u32 *b,
> unsigned long base, unsigned long limit, unsigned char type, unsigned char flags)
>{
> *a = ((base & 0xffff) << 16) | (limit & 0xffff);
> *b = (base & 0xff000000) | ((base & 0xff0000) >> 16) |
>  (limit & 0x000f0000) | ((type & 0xff) << 8) | ((flags & 0xf) << 20);
>}
>
>static inline __attribute__((always_inline)) void pack_gate(__u32 *a, __u32 *b,
> unsigned long base, unsigned short seg, unsigned char type, unsigned char flags)
>{
> *a = (seg << 16) | (base & 0xffff);
> *b = (base & 0xffff0000) | ((type & 0xff) << 8) | (flags & 0xff);
>}
># 81 "include/asm/desc_32.h"
>static inline __attribute__((always_inline)) void write_dt_entry(struct desc_struct *dt,
>      int entry, u32 entry_low, u32 entry_high)
>{
> dt[entry].a = entry_low;
> dt[entry].b = entry_high;
>}
>
>static inline __attribute__((always_inline)) void native_set_ldt(const void *addr, unsigned int entries)
>{
> if (__builtin_expect(!!(entries == 0), 1))
>  __asm__ __volatile__("lldt %w0"::"q" (0));
> else {
>  unsigned cpu = (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; }));
>  __u32 a, b;
>
>  pack_descriptor(&a, &b, (unsigned long)addr,
>    entries * sizeof(struct desc_struct) - 1,
>    0x82, 0);
>  write_dt_entry(get_cpu_gdt_table(cpu), (12 + 5), a, b);
>  __asm__ __volatile__("lldt %w0"::"q" ((12 + 5)*8));
> }
>}
>
>
>static inline __attribute__((always_inline)) void native_load_tr_desc(void)
>{
> asm volatile("ltr %w0"::"q" ((12 + 4)*8));
>}
>
>static inline __attribute__((always_inline)) void native_load_gdt(const struct Xgt_desc_struct *dtr)
>{
> asm volatile("lgdt %0"::"m" (*dtr));
>}
>
>static inline __attribute__((always_inline)) void native_load_idt(const struct Xgt_desc_struct *dtr)
>{
> asm volatile("lidt %0"::"m" (*dtr));
>}
>
>static inline __attribute__((always_inline)) void native_store_gdt(struct Xgt_desc_struct *dtr)
>{
> asm ("sgdt %0":"=m" (*dtr));
>}
>
>static inline __attribute__((always_inline)) void native_store_idt(struct Xgt_desc_struct *dtr)
>{
> asm ("sidt %0":"=m" (*dtr));
>}
>
>static inline __attribute__((always_inline)) unsigned long native_store_tr(void)
>{
> unsigned long tr;
> asm ("str %0":"=r" (tr));
> return tr;
>}
>
>static inline __attribute__((always_inline)) void native_load_tls(struct thread_struct *t, unsigned int cpu)
>{
> unsigned int i;
> struct desc_struct *gdt = get_cpu_gdt_table(cpu);
>
> for (i = 0; i < 3; i++)
>  gdt[6 + i] = t->tls_array[i];
>}
>
>static inline __attribute__((always_inline)) void _set_gate(int gate, unsigned int type, void *addr, unsigned short seg)
>{
> __u32 a, b;
> pack_gate(&a, &b, (unsigned long)addr, seg, type, 0);
> write_dt_entry(idt_table, gate, a, b);
>}
>
>static inline __attribute__((always_inline)) void __set_tss_desc(unsigned int cpu, unsigned int entry, const void *addr)
>{
> __u32 a, b;
> pack_descriptor(&a, &b, (unsigned long)addr,
>   __builtin_offsetof(struct tss_struct,__cacheline_filler) - 1,
>   0x89, 0);
> write_dt_entry(get_cpu_gdt_table(cpu), entry, a, b);
>}
># 190 "include/asm/desc_32.h"
>static inline __attribute__((always_inline)) void clear_LDT(void)
>{
> native_set_ldt(((void *)0), 0);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void load_LDT_nolock(mm_context_t *pc)
>{
> native_set_ldt(pc->ldt, pc->size);
>}
>
>static inline __attribute__((always_inline)) void load_LDT(mm_context_t *pc)
>{
> do { } while (0);
> load_LDT_nolock(pc);
> do { } while (0);
>}
>
>static inline __attribute__((always_inline)) unsigned long get_desc_base(unsigned long *desc)
>{
> unsigned long base;
> base = ((desc[0] >> 16) & 0x0000ffff) |
>  ((desc[1] << 16) & 0x00ff0000) |
>  (desc[1] & 0xff000000);
> return base;
>}
># 3 "include/asm/desc.h" 2
># 81 "include/asm/elf.h" 2
># 128 "include/asm/elf.h"
>extern unsigned int vdso_enabled;
># 233 "include/asm/elf.h"
>struct task_struct;
>
>extern int dump_task_regs (struct task_struct *, elf_gregset_t *);
>extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
>
>
>
>
>
>extern int dump_task_extended_fpu (struct task_struct *,
>       struct user_fxsr_struct *);
># 258 "include/asm/elf.h"
>extern void __kernel_vsyscall;
># 282 "include/asm/elf.h"
>struct linux_binprm;
>
>
>extern int arch_setup_additional_pages(struct linux_binprm *bprm,
>           int executable_stack);
># 7 "include/linux/elf.h" 2
>
>struct file;
># 18 "include/linux/elf.h"
>typedef __u32 Elf32_Addr;
>typedef __u16 Elf32_Half;
>typedef __u32 Elf32_Off;
>typedef __s32 Elf32_Sword;
>typedef __u32 Elf32_Word;
>
>
>typedef __u64 Elf64_Addr;
>typedef __u16 Elf64_Half;
>typedef __s16 Elf64_SHalf;
>typedef __u64 Elf64_Off;
>typedef __s32 Elf64_Sword;
>typedef __u32 Elf64_Word;
>typedef __u64 Elf64_Xword;
>typedef __s64 Elf64_Sxword;
># 125 "include/linux/elf.h"
>typedef struct dynamic{
>  Elf32_Sword d_tag;
>  union{
>    Elf32_Sword d_val;
>    Elf32_Addr d_ptr;
>  } d_un;
>} Elf32_Dyn;
>
>typedef struct {
>  Elf64_Sxword d_tag;
>  union {
>    Elf64_Xword d_val;
>    Elf64_Addr d_ptr;
>  } d_un;
>} Elf64_Dyn;
># 148 "include/linux/elf.h"
>typedef struct elf32_rel {
>  Elf32_Addr r_offset;
>  Elf32_Word r_info;
>} Elf32_Rel;
>
>typedef struct elf64_rel {
>  Elf64_Addr r_offset;
>  Elf64_Xword r_info;
>} Elf64_Rel;
>
>typedef struct elf32_rela{
>  Elf32_Addr r_offset;
>  Elf32_Word r_info;
>  Elf32_Sword r_addend;
>} Elf32_Rela;
>
>typedef struct elf64_rela {
>  Elf64_Addr r_offset;
>  Elf64_Xword r_info;
>  Elf64_Sxword r_addend;
>} Elf64_Rela;
>
>typedef struct elf32_sym{
>  Elf32_Word st_name;
>  Elf32_Addr st_value;
>  Elf32_Word st_size;
>  unsigned char st_info;
>  unsigned char st_other;
>  Elf32_Half st_shndx;
>} Elf32_Sym;
>
>typedef struct elf64_sym {
>  Elf64_Word st_name;
>  unsigned char st_info;
>  unsigned char st_other;
>  Elf64_Half st_shndx;
>  Elf64_Addr st_value;
>  Elf64_Xword st_size;
>} Elf64_Sym;
>
>
>
>
>typedef struct elf32_hdr{
>  unsigned char e_ident[16];
>  Elf32_Half e_type;
>  Elf32_Half e_machine;
>  Elf32_Word e_version;
>  Elf32_Addr e_entry;
>  Elf32_Off e_phoff;
>  Elf32_Off e_shoff;
>  Elf32_Word e_flags;
>  Elf32_Half e_ehsize;
>  Elf32_Half e_phentsize;
>  Elf32_Half e_phnum;
>  Elf32_Half e_shentsize;
>  Elf32_Half e_shnum;
>  Elf32_Half e_shstrndx;
>} Elf32_Ehdr;
>
>typedef struct elf64_hdr {
>  unsigned char e_ident[16];
>  Elf64_Half e_type;
>  Elf64_Half e_machine;
>  Elf64_Word e_version;
>  Elf64_Addr e_entry;
>  Elf64_Off e_phoff;
>  Elf64_Off e_shoff;
>  Elf64_Word e_flags;
>  Elf64_Half e_ehsize;
>  Elf64_Half e_phentsize;
>  Elf64_Half e_phnum;
>  Elf64_Half e_shentsize;
>  Elf64_Half e_shnum;
>  Elf64_Half e_shstrndx;
>} Elf64_Ehdr;
>
>
>
>
>
>
>
>typedef struct elf32_phdr{
>  Elf32_Word p_type;
>  Elf32_Off p_offset;
>  Elf32_Addr p_vaddr;
>  Elf32_Addr p_paddr;
>  Elf32_Word p_filesz;
>  Elf32_Word p_memsz;
>  Elf32_Word p_flags;
>  Elf32_Word p_align;
>} Elf32_Phdr;
>
>typedef struct elf64_phdr {
>  Elf64_Word p_type;
>  Elf64_Word p_flags;
>  Elf64_Off p_offset;
>  Elf64_Addr p_vaddr;
>  Elf64_Addr p_paddr;
>  Elf64_Xword p_filesz;
>  Elf64_Xword p_memsz;
>  Elf64_Xword p_align;
>} Elf64_Phdr;
># 287 "include/linux/elf.h"
>typedef struct {
>  Elf32_Word sh_name;
>  Elf32_Word sh_type;
>  Elf32_Word sh_flags;
>  Elf32_Addr sh_addr;
>  Elf32_Off sh_offset;
>  Elf32_Word sh_size;
>  Elf32_Word sh_link;
>  Elf32_Word sh_info;
>  Elf32_Word sh_addralign;
>  Elf32_Word sh_entsize;
>} Elf32_Shdr;
>
>typedef struct elf64_shdr {
>  Elf64_Word sh_name;
>  Elf64_Word sh_type;
>  Elf64_Xword sh_flags;
>  Elf64_Addr sh_addr;
>  Elf64_Off sh_offset;
>  Elf64_Xword sh_size;
>  Elf64_Word sh_link;
>  Elf64_Word sh_info;
>  Elf64_Xword sh_addralign;
>  Elf64_Xword sh_entsize;
>} Elf64_Shdr;
># 361 "include/linux/elf.h"
>typedef struct elf32_note {
>  Elf32_Word n_namesz;
>  Elf32_Word n_descsz;
>  Elf32_Word n_type;
>} Elf32_Nhdr;
>
>
>typedef struct elf64_note {
>  Elf64_Word n_namesz;
>  Elf64_Word n_descsz;
>  Elf64_Word n_type;
>} Elf64_Nhdr;
>
>
>
>extern Elf32_Dyn _DYNAMIC [];
># 394 "include/linux/elf.h"
>static inline __attribute__((always_inline)) int elf_coredump_extra_notes_size(void) { return 0; }
>static inline __attribute__((always_inline)) int elf_coredump_extra_notes_write(struct file *file,
>   loff_t *foffset) { return 0; }
># 15 "include/linux/module.h" 2
>
>
># 1 "include/linux/moduleparam.h" 1
># 29 "include/linux/moduleparam.h"
>struct kernel_param;
>
>
>typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);
>
>typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);
>
>struct kernel_param {
> const char *name;
> unsigned int perm;
> param_set_fn set;
> param_get_fn get;
> union {
>  void *arg;
>  const struct kparam_string *str;
>  const struct kparam_array *arr;
> };
>};
>
>
>struct kparam_string {
> unsigned int maxlen;
> char *string;
>};
>
>
>struct kparam_array
>{
> unsigned int max;
> unsigned int *num;
> param_set_fn set;
> param_get_fn get;
> unsigned int elemsize;
> void *elem;
>};
># 102 "include/linux/moduleparam.h"
>extern int parse_args(const char *name,
>        char *args,
>        struct kernel_param *params,
>        unsigned num,
>        int (*unknown)(char *param, char *val));
>
>
>
>
>
>
>
>extern int param_set_byte(const char *val, struct kernel_param *kp);
>extern int param_get_byte(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_short(const char *val, struct kernel_param *kp);
>extern int param_get_short(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_ushort(const char *val, struct kernel_param *kp);
>extern int param_get_ushort(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_int(const char *val, struct kernel_param *kp);
>extern int param_get_int(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_uint(const char *val, struct kernel_param *kp);
>extern int param_get_uint(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_long(const char *val, struct kernel_param *kp);
>extern int param_get_long(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_ulong(const char *val, struct kernel_param *kp);
>extern int param_get_ulong(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_charp(const char *val, struct kernel_param *kp);
>extern int param_get_charp(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_bool(const char *val, struct kernel_param *kp);
>extern int param_get_bool(char *buffer, struct kernel_param *kp);
>
>
>extern int param_set_invbool(const char *val, struct kernel_param *kp);
>extern int param_get_invbool(char *buffer, struct kernel_param *kp);
># 166 "include/linux/moduleparam.h"
>extern int param_array_set(const char *val, struct kernel_param *kp);
>extern int param_array_get(char *buffer, struct kernel_param *kp);
>
>extern int param_set_copystring(const char *val, struct kernel_param *kp);
>extern int param_get_string(char *buffer, struct kernel_param *kp);
>
>
>
>struct module;
>
>
>extern int module_param_sysfs_setup(struct module *mod,
>        struct kernel_param *kparam,
>        unsigned int num_params);
>
>extern void module_param_sysfs_remove(struct module *mod);
># 18 "include/linux/module.h" 2
># 1 "include/linux/marker.h" 1
># 17 "include/linux/marker.h"
>struct module;
>struct marker;
># 30 "include/linux/marker.h"
>typedef void marker_probe_func(const struct marker *mdata,
> void *private_data, const char *fmt, ...);
>
>struct marker {
> const char *name;
> const char *format;
>
>
> char state;
> marker_probe_func *call;
> void *private;
>} __attribute__((aligned(8)));
># 79 "include/linux/marker.h"
>static inline __attribute__((always_inline)) void marker_update_probe_range(struct marker *begin,
> struct marker *end, struct module *probe_module, int *refcount)
>{ }
># 103 "include/linux/marker.h"
>static inline __attribute__((always_inline)) void __attribute__((format(printf,1,2))) __mark_check_format(const char *fmt, ...)
>{
>}
>
>extern marker_probe_func __mark_empty_function;
>
>
>
>
>
>extern int marker_probe_register(const char *name, const char *format,
>    marker_probe_func *probe, void *private);
>
>
>
>
>extern void *marker_probe_unregister(const char *name);
>
>
>
>extern void *marker_probe_unregister_private_data(void *private);
>
>extern int marker_arm(const char *name);
>extern int marker_disarm(const char *name);
>extern void *marker_get_private_data(const char *name);
># 19 "include/linux/module.h" 2
># 1 "include/asm/local.h" 1
>
># 1 "include/asm/local_32.h" 1
>
>
>
>
># 1 "include/asm/system.h" 1
># 6 "include/asm/local_32.h" 2
># 1 "include/asm/atomic.h" 1
># 7 "include/asm/local_32.h" 2
>
>typedef struct
>{
> atomic_long_t a;
>} local_t;
>
>
>
>
>
>
>static __inline__ __attribute__((always_inline)) void local_inc(local_t *l)
>{
> __asm__ __volatile__(
>  "incl %0"
>  :"+m" (l->a.counter));
>}
>
>static __inline__ __attribute__((always_inline)) void local_dec(local_t *l)
>{
> __asm__ __volatile__(
>  "decl %0"
>  :"+m" (l->a.counter));
>}
>
>static __inline__ __attribute__((always_inline)) void local_add(long i, local_t *l)
>{
> __asm__ __volatile__(
>  "addl %1,%0"
>  :"+m" (l->a.counter)
>  :"ir" (i));
>}
>
>static __inline__ __attribute__((always_inline)) void local_sub(long i, local_t *l)
>{
> __asm__ __volatile__(
>  "subl %1,%0"
>  :"+m" (l->a.counter)
>  :"ir" (i));
>}
># 57 "include/asm/local_32.h"
>static __inline__ __attribute__((always_inline)) int local_sub_and_test(long i, local_t *l)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  "subl %2,%0; sete %1"
>  :"+m" (l->a.counter), "=qm" (c)
>  :"ir" (i) : "memory");
> return c;
>}
># 76 "include/asm/local_32.h"
>static __inline__ __attribute__((always_inline)) int local_dec_and_test(local_t *l)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  "decl %0; sete %1"
>  :"+m" (l->a.counter), "=qm" (c)
>  : : "memory");
> return c != 0;
>}
># 95 "include/asm/local_32.h"
>static __inline__ __attribute__((always_inline)) int local_inc_and_test(local_t *l)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  "incl %0; sete %1"
>  :"+m" (l->a.counter), "=qm" (c)
>  : : "memory");
> return c != 0;
>}
># 115 "include/asm/local_32.h"
>static __inline__ __attribute__((always_inline)) int local_add_negative(long i, local_t *l)
>{
> unsigned char c;
>
> __asm__ __volatile__(
>  "addl %2,%0; sets %1"
>  :"+m" (l->a.counter), "=qm" (c)
>  :"ir" (i) : "memory");
> return c;
>}
># 133 "include/asm/local_32.h"
>static __inline__ __attribute__((always_inline)) long local_add_return(long i, local_t *l)
>{
> long __i;
>
>
>
>
>
>
> __i = i;
> __asm__ __volatile__(
>  "xaddl %0, %1;"
>  :"+r" (i), "+m" (l->a.counter)
>  : : "memory");
> return i + __i;
># 157 "include/asm/local_32.h"
>}
>
>static __inline__ __attribute__((always_inline)) long local_sub_return(long i, local_t *l)
>{
> return local_add_return(-i,l);
>}
># 3 "include/asm/local.h" 2
># 20 "include/linux/module.h" 2
>
># 1 "include/asm/module.h" 1
>
># 1 "include/asm/module_32.h" 1
>
>
>
>
>struct mod_arch_specific
>{
>};
># 3 "include/asm/module.h" 2
># 22 "include/linux/module.h" 2
># 33 "include/linux/module.h"
>struct kernel_symbol
>{
> unsigned long value;
> const char *name;
>};
>
>struct modversion_info
>{
> unsigned long crc;
> char name[(64 - sizeof(unsigned long))];
>};
>
>struct module;
>
>struct module_attribute {
>        struct attribute attr;
>        ssize_t (*show)(struct module_attribute *, struct module *, char *);
>        ssize_t (*store)(struct module_attribute *, struct module *,
>    const char *, size_t count);
> void (*setup)(struct module *, const char *);
> int (*test)(struct module *);
> void (*free)(struct module *);
>};
>
>struct module_kobject
>{
> struct kobject kobj;
> struct module *mod;
> struct kobject *drivers_dir;
>};
>
>
>extern int init_module(void);
>extern void cleanup_module(void);
>
>
>struct exception_table_entry;
>
>const struct exception_table_entry *
>search_extable(const struct exception_table_entry *first,
>        const struct exception_table_entry *last,
>        unsigned long value);
>void sort_extable(struct exception_table_entry *start,
>    struct exception_table_entry *finish);
>void sort_main_extable(void);
># 163 "include/linux/module.h"
>const struct exception_table_entry *search_exception_tables(unsigned long add);
>
>struct notifier_block;
>
>
>
>
>void *__symbol_get(const char *symbol);
>void *__symbol_get_gpl(const char *symbol);
># 220 "include/linux/module.h"
>struct module_ref
>{
> local_t count;
>} __attribute__((__aligned__((1 << (7)))));
>
>enum module_state
>{
> MODULE_STATE_LIVE,
> MODULE_STATE_COMING,
> MODULE_STATE_GOING,
>};
>
>
>struct module_sect_attr
>{
> struct module_attribute mattr;
> char *name;
> unsigned long address;
>};
>
>struct module_sect_attrs
>{
> struct attribute_group grp;
> int nsections;
> struct module_sect_attr attrs[0];
>};
>
>struct module_param_attrs;
>
>struct module
>{
> enum module_state state;
>
>
> struct list_head list;
>
>
> char name[(64 - sizeof(unsigned long))];
>
>
> struct module_kobject mkobj;
> struct module_param_attrs *param_attrs;
> struct module_attribute *modinfo_attrs;
> const char *version;
> const char *srcversion;
> struct kobject *holders_dir;
>
>
> const struct kernel_symbol *syms;
> unsigned int num_syms;
> const unsigned long *crcs;
>
>
> const struct kernel_symbol *gpl_syms;
> unsigned int num_gpl_syms;
> const unsigned long *gpl_crcs;
>
>
> const struct kernel_symbol *unused_syms;
> unsigned int num_unused_syms;
> const unsigned long *unused_crcs;
>
> const struct kernel_symbol *unused_gpl_syms;
> unsigned int num_unused_gpl_syms;
> const unsigned long *unused_gpl_crcs;
>
>
> const struct kernel_symbol *gpl_future_syms;
> unsigned int num_gpl_future_syms;
> const unsigned long *gpl_future_crcs;
>
>
> unsigned int num_exentries;
> const struct exception_table_entry *extable;
>
>
> int (*init)(void);
>
>
> void *module_init;
>
>
> void *module_core;
>
>
> unsigned long init_size, core_size;
>
>
> unsigned long init_text_size, core_text_size;
>
>
> void *unwind_info;
>
>
> struct mod_arch_specific arch;
>
> unsigned int taints;
>
>
>
> struct list_head bug_list;
> struct bug_entry *bug_table;
> unsigned num_bugs;
>
>
>
>
> struct module_ref ref[32];
>
>
> struct list_head modules_which_use_me;
>
>
> struct task_struct *waiter;
>
>
> void (*exit)(void);
>
>
>
>
> Elf32_Sym *symtab;
> unsigned long num_symtab;
> char *strtab;
>
>
> struct module_sect_attrs *sect_attrs;
>
>
> struct module_notes_attrs *notes_attrs;
>
>
>
> void *percpu;
>
>
>
> char *args;
>
>
>
>
>};
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int module_is_live(struct module *mod)
>{
> return mod->state != MODULE_STATE_GOING;
>}
>
>
>struct module *module_text_address(unsigned long addr);
>struct module *__module_text_address(unsigned long addr);
>int is_module_address(unsigned long addr);
>
>
>
>int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
>   char *name, char *module_name, int *exported);
>
>
>unsigned long module_kallsyms_lookup_name(const char *name);
>
>extern void __module_put_and_exit(struct module *mod, long code)
> __attribute__((noreturn));
>
>
>
>unsigned int module_refcount(struct module *mod);
>void __symbol_put(const char *symbol);
>
>void symbol_put_addr(void *addr);
>
>
>
>static inline __attribute__((always_inline)) void __module_get(struct module *module)
>{
> if (module) {
>  do { if (__builtin_expect(!!(module_refcount(module) == 0), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("include/linux/module.h"), "i" (403), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
>  local_inc(&module->ref[({ do { } while (0); (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; })); })].count);
>  do { } while (0);
> }
>}
>
>static inline __attribute__((always_inline)) int try_module_get(struct module *module)
>{
> int ret = 1;
>
> if (module) {
>  unsigned int cpu = ({ do { } while (0); (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; })); });
>  if (__builtin_expect(!!(module_is_live(module)), 1))
>   local_inc(&module->ref[cpu].count);
>  else
>   ret = 0;
>  do { } while (0);
> }
> return ret;
>}
>
>extern void module_put(struct module *module);
># 450 "include/linux/module.h"
>const char *module_address_lookup(unsigned long addr,
>      unsigned long *symbolsize,
>      unsigned long *offset,
>      char **modname);
>int lookup_module_symbol_name(unsigned long addr, char *symname);
>int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
>
>
>const struct exception_table_entry *search_module_extables(unsigned long addr);
>
>int register_module_notifier(struct notifier_block * nb);
>int unregister_module_notifier(struct notifier_block * nb);
>
>extern void print_modules(void);
>
>extern void module_update_markers(struct module *probe_module, int *refcount);
># 573 "include/linux/module.h"
>struct device_driver;
>
>struct module;
>
>extern struct kset module_subsys;
>
>int mod_sysfs_init(struct module *mod);
>int mod_sysfs_setup(struct module *mod,
>      struct kernel_param *kparam,
>      unsigned int num_params);
>int module_add_modinfo_attrs(struct module *mod);
>void module_remove_modinfo_attrs(struct module *mod);
># 612 "include/linux/module.h"
>void module_add_driver(struct module *mod, struct device_driver *drv);
>void module_remove_driver(struct device_driver *drv);
># 26 "include/linux/sysdev.h" 2
>
>
>
>struct sys_device;
>
>struct sysdev_class {
> struct list_head drivers;
>
>
> int (*shutdown)(struct sys_device *);
> int (*suspend)(struct sys_device *, pm_message_t state);
> int (*resume)(struct sys_device *);
> struct kset kset;
>};
>
>struct sysdev_class_attribute {
> struct attribute attr;
> ssize_t (*show)(struct sysdev_class *, char *);
> ssize_t (*store)(struct sysdev_class *, const char *, size_t);
>};
># 55 "include/linux/sysdev.h"
>extern int sysdev_class_register(struct sysdev_class *);
>extern void sysdev_class_unregister(struct sysdev_class *);
>
>extern int sysdev_class_create_file(struct sysdev_class *,
> struct sysdev_class_attribute *);
>extern void sysdev_class_remove_file(struct sysdev_class *,
> struct sysdev_class_attribute *);
>
>
>
>
>struct sysdev_driver {
> struct list_head entry;
> int (*add)(struct sys_device *);
> int (*remove)(struct sys_device *);
> int (*shutdown)(struct sys_device *);
> int (*suspend)(struct sys_device *, pm_message_t state);
> int (*resume)(struct sys_device *);
>};
>
>
>extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
>extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);
>
>
>
>
>
>
>
>struct sys_device {
> u32 id;
> struct sysdev_class * cls;
> struct kobject kobj;
>};
>
>extern int sysdev_register(struct sys_device *);
>extern void sysdev_unregister(struct sys_device *);
>
>
>struct sysdev_attribute {
> struct attribute attr;
> ssize_t (*show)(struct sys_device *, char *);
> ssize_t (*store)(struct sys_device *, const char *, size_t);
>};
># 112 "include/linux/sysdev.h"
>extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
>extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
># 23 "include/linux/cpu.h" 2
># 1 "include/linux/node.h" 1
># 25 "include/linux/node.h"
>struct node {
> struct sys_device sysdev;
>};
>
>extern struct node node_devices[];
>
>extern int register_node(struct node *, int, struct node *);
>extern void unregister_node(struct node *node);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int register_one_node(int nid)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int unregister_one_node(int nid)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int register_cpu_under_node(unsigned int cpu, unsigned int nid)
>{
> return 0;
>}
>static inline __attribute__((always_inline)) int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
>{
> return 0;
>}
># 24 "include/linux/cpu.h" 2
>
>
># 1 "include/asm/semaphore.h" 1
>
># 1 "include/asm/semaphore_32.h" 1
># 39 "include/asm/semaphore_32.h"
># 1 "include/asm/system.h" 1
># 40 "include/asm/semaphore_32.h" 2
># 1 "include/asm/atomic.h" 1
># 41 "include/asm/semaphore_32.h" 2
>
>
>
>struct semaphore {
> atomic_t count;
> int sleepers;
> wait_queue_head_t wait;
>};
># 63 "include/asm/semaphore_32.h"
>static inline __attribute__((always_inline)) void sema_init (struct semaphore *sem, int val)
>{
>
>
>
>
>
>
> (((&sem->count)->counter) = (val));
> sem->sleepers = 0;
> init_waitqueue_head(&sem->wait);
>}
>
>static inline __attribute__((always_inline)) void init_MUTEX (struct semaphore *sem)
>{
> sema_init(sem, 1);
>}
>
>static inline __attribute__((always_inline)) void init_MUTEX_LOCKED (struct semaphore *sem)
>{
> sema_init(sem, 0);
>}
>
>__attribute__((regparm(3))) void __down_failed(void );
>__attribute__((regparm(3))) int __down_failed_interruptible(void );
>__attribute__((regparm(3))) int __down_failed_trylock(void );
>__attribute__((regparm(3))) void __up_wakeup(void );
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void down(struct semaphore * sem)
>{
> do { cond_resched(); } while (0);
> __asm__ __volatile__(
>  "# atomic down operation\n\t"
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "decl %0\n\t"
>  "jns 2f\n"
>  "\tlea %0,%%eax\n\t"
>  "call __down_failed\n"
>  "2:"
>  :"+m" (sem->count)
>  :
>  :"memory","ax");
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int down_interruptible(struct semaphore * sem)
>{
> int result;
>
> do { cond_resched(); } while (0);
> __asm__ __volatile__(
>  "# atomic interruptible down operation\n\t"
>  "xorl %0,%0\n\t"
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "decl %1\n\t"
>  "jns 2f\n\t"
>  "lea %1,%%eax\n\t"
>  "call __down_failed_interruptible\n"
>  "2:"
>  :"=&a" (result), "+m" (sem->count)
>  :
>  :"memory");
> return result;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int down_trylock(struct semaphore * sem)
>{
> int result;
>
> __asm__ __volatile__(
>  "# atomic interruptible down operation\n\t"
>  "xorl %0,%0\n\t"
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "decl %1\n\t"
>  "jns 2f\n\t"
>  "lea %1,%%eax\n\t"
>  "call __down_failed_trylock\n\t"
>  "2:\n"
>  :"=&a" (result), "+m" (sem->count)
>  :
>  :"memory");
> return result;
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void up(struct semaphore * sem)
>{
> __asm__ __volatile__(
>  "# atomic up operation\n\t"
>  ".section .smp_locks,\"a\"\n" "  .align 4\n" "  .long 661f\n" ".previous\n" "661:\n\tlock; " "incl %0\n\t"
>  "jg 1f\n\t"
>  "lea %0,%%eax\n\t"
>  "call __up_wakeup\n"
>  "1:"
>  :"+m" (sem->count)
>  :
>  :"memory","ax");
>}
># 3 "include/asm/semaphore.h" 2
># 27 "include/linux/cpu.h" 2
>
>
>struct cpu {
> int node_id;
> int hotpluggable;
> struct sys_device sysdev;
>};
>
>extern int register_cpu(struct cpu *cpu, int num);
>extern struct sys_device *get_cpu_sysdev(unsigned cpu);
>
>extern int cpu_add_sysdev_attr(struct sysdev_attribute *attr);
>extern void cpu_remove_sysdev_attr(struct sysdev_attribute *attr);
>
>extern int cpu_add_sysdev_attr_group(struct attribute_group *attrs);
>extern void cpu_remove_sysdev_attr_group(struct attribute_group *attrs);
>
>extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls);
>
>
>extern void unregister_cpu(struct cpu *cpu);
>
>struct notifier_block;
>
>
>
>
>extern int register_cpu_notifier(struct notifier_block *nb);
>extern void unregister_cpu_notifier(struct notifier_block *nb);
># 72 "include/linux/cpu.h"
>int cpu_up(unsigned int cpu);
># 85 "include/linux/cpu.h"
>extern struct sysdev_class cpu_sysdev_class;
>
>
>
>
>static inline __attribute__((always_inline)) void cpuhotplug_mutex_lock(struct mutex *cpu_hp_mutex)
>{
> mutex_lock(cpu_hp_mutex);
>}
>
>static inline __attribute__((always_inline)) void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
>{
> mutex_unlock(cpu_hp_mutex);
>}
>
>extern void lock_cpu_hotplug(void);
>extern void unlock_cpu_hotplug(void);
>
>
>
>
>
>
>
>int cpu_down(unsigned int cpu);
># 131 "include/linux/cpu.h"
>extern int suspend_cpu_hotplug;
>
>extern int disable_nonboot_cpus(void);
>extern void enable_nonboot_cpus(void);
># 35 "kernel/hrtimer.c" 2
># 1 "include/linux/irq.h" 1
># 20 "include/linux/irq.h"
># 1 "include/linux/irqreturn.h" 1
># 19 "include/linux/irqreturn.h"
>typedef int irqreturn_t;
># 21 "include/linux/irq.h" 2
>
>
># 1 "include/asm/irq.h" 1
>
># 1 "include/asm/irq_32.h" 1
># 13 "include/asm/irq_32.h"
># 1 "include/linux/sched.h" 1
># 43 "include/linux/sched.h"
>struct sched_param {
> int sched_priority;
>};
>
># 1 "include/asm/param.h" 1
># 48 "include/linux/sched.h" 2
>
># 1 "include/linux/capability.h" 1
># 19 "include/linux/capability.h"
>struct task_struct;
># 34 "include/linux/capability.h"
>typedef struct __user_cap_header_struct {
> __u32 version;
> int pid;
>} *cap_user_header_t;
>
>typedef struct __user_cap_data_struct {
>        __u32 effective;
>        __u32 permitted;
>        __u32 inheritable;
>} *cap_user_data_t;
># 57 "include/linux/capability.h"
>struct vfs_cap_data {
> __u32 magic_etc;
> __u32 permitted;
> __u32 inheritable;
>};
># 75 "include/linux/capability.h"
>typedef __u32 kernel_cap_t;
># 338 "include/linux/capability.h"
>static inline __attribute__((always_inline)) kernel_cap_t cap_combine(kernel_cap_t a, kernel_cap_t b)
>{
>     kernel_cap_t dest;
>     (dest) = (a) | (b);
>     return dest;
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_intersect(kernel_cap_t a, kernel_cap_t b)
>{
>     kernel_cap_t dest;
>     (dest) = (a) & (b);
>     return dest;
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_drop(kernel_cap_t a, kernel_cap_t drop)
>{
>     kernel_cap_t dest;
>     (dest) = (a) & ~(drop);
>     return dest;
>}
>
>static inline __attribute__((always_inline)) kernel_cap_t cap_invert(kernel_cap_t c)
>{
>     kernel_cap_t dest;
>     (dest) = ~(c);
>     return dest;
>}
># 375 "include/linux/capability.h"
>int capable(int cap);
>int __capable(struct task_struct *t, int cap);
># 50 "include/linux/sched.h" 2
>
>
>
># 1 "include/linux/timex.h" 1
># 100 "include/linux/timex.h"
>struct timex {
> unsigned int modes;
> long offset;
> long freq;
> long maxerror;
> long esterror;
> int status;
> long constant;
> long precision;
> long tolerance;
>
>
> struct timeval time;
> long tick;
>
> long ppsfreq;
> long jitter;
> int shift;
> long stabil;
> long jitcnt;
> long calcnt;
> long errcnt;
> long stbcnt;
>
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32; int :32;
>};
># 188 "include/linux/timex.h"
># 1 "include/asm/timex.h" 1
>
>
>
>
># 1 "include/asm/processor.h" 1
># 6 "include/asm/timex.h" 2
># 1 "include/asm/tsc.h" 1
>
>
>
>
>
>
># 1 "include/asm/processor.h" 1
># 8 "include/asm/tsc.h" 2
>
>
>
>
>
>
>
>typedef unsigned long long cycles_t;
>
>extern unsigned int cpu_khz;
>extern unsigned int tsc_khz;
>
>static inline __attribute__((always_inline)) cycles_t get_cycles(void)
>{
> unsigned long long ret = 0;
>
>
>
>
>
>
>
> ((ret) = native_read_tsc());
>
> return ret;
>}
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) cycles_t get_cycles_sync(void)
>{
> unsigned long long ret;
> unsigned eax, edx;
>
>
>
>
>
> asm volatile ("661:\n\t" ".byte 0x66,0x66,0x90\n" "\n662:\n" ".section .altinstructions,\"a\"\n" "  .align 4\n" "  .long 661b\n" "  .long 663f\n" "  .byte %c[feat]\n" "  .byte 662b-661b\n" "  .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" ".byte 0x0f,0x01,0xf9" "\n664:\n" ".previous" : "=a" (eax), "=d" (edx) : [feat] "i" ((1*32+27)), "a" (0U), "d" (0U) : "ecx", "memory");
>
>
> ret = (((unsigned long long)edx) << 32) | ((unsigned long long)eax);
> if (ret)
>  return ret;
>
>
>
>
>
> asm volatile ("661:\n\t" "cpuid" "\n662:\n" ".section .altinstructions,\"a\"\n" "  .align 4\n" "  .long 661b\n" "  .long 663f\n" "  .byte %c[feat]\n" "  .byte 662b-661b\n" "  .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" ".byte 0x66,0x90\n" "\n664:\n" ".previous" : "=a" (eax) : [feat] "i" ((3*32+15)), "0" (1) : "ebx","ecx","edx","memory");
>
> ((ret) = native_read_tsc());
>
> return ret;
>}
>
>extern void tsc_init(void);
>extern void mark_tsc_unstable(char *reason);
>extern int unsynchronized_tsc(void);
>extern void init_tsc_clocksource(void);
>int check_tsc_unstable(void);
>
>
>
>
>
>extern void check_tsc_sync_source(int cpu);
>extern void check_tsc_sync_target(void);
># 7 "include/asm/timex.h" 2
># 15 "include/asm/timex.h"
>extern int read_current_timer(unsigned long *timer_value);
># 189 "include/linux/timex.h" 2
>
>
>
>
>
>
>extern unsigned long tick_usec;
>extern unsigned long tick_nsec;
>extern int tickadj;
>
>
>
>
>extern int time_status;
>extern long time_maxerror;
>extern long time_esterror;
>
>extern long time_freq;
>
>extern long time_adjust;
>
>extern void ntp_clear(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) int ntp_synced(void)
>{
> return !(time_status & 0x0040);
>}
># 238 "include/linux/timex.h"
>extern u64 current_tick_length(void);
>
>extern void second_overflow(void);
>extern void update_ntp_one_tick(void);
>extern int do_adjtimex(struct timex *);
># 54 "include/linux/sched.h" 2
># 1 "include/linux/jiffies.h" 1
>
>
>
># 1 "include/linux/calc64.h" 1
># 35 "include/linux/calc64.h"
>static inline __attribute__((always_inline)) long div_long_long_rem_signed(const long long dividend,
>         const long divisor, long *remainder)
>{
> long res;
>
> if (__builtin_expect(!!(dividend < 0), 0)) {
>  res = -div_ll_X_l_rem(-dividend,divisor,remainder);
>  *remainder = -(*remainder);
> } else
>  res = div_ll_X_l_rem(dividend,divisor,remainder);
>
> return res;
>}
># 5 "include/linux/jiffies.h" 2
># 75 "include/linux/jiffies.h"
>extern u64 __attribute__((section(".data"))) jiffies_64;
>extern unsigned long volatile __attribute__((section(".data"))) jiffies;
>
>
>u64 get_jiffies_64(void);
># 151 "include/linux/jiffies.h"
>extern unsigned long preset_lpj;
># 264 "include/linux/jiffies.h"
>extern unsigned int jiffies_to_msecs(const unsigned long j);
>extern unsigned int jiffies_to_usecs(const unsigned long j);
>extern unsigned long msecs_to_jiffies(const unsigned int m);
>extern unsigned long usecs_to_jiffies(const unsigned int u);
>extern unsigned long timespec_to_jiffies(const struct timespec *value);
>extern void jiffies_to_timespec(const unsigned long jiffies,
>    struct timespec *value);
>extern unsigned long timeval_to_jiffies(const struct timeval *value);
>extern void jiffies_to_timeval(const unsigned long jiffies,
>          struct timeval *value);
>extern clock_t jiffies_to_clock_t(long x);
>extern unsigned long clock_t_to_jiffies(unsigned long x);
>extern u64 jiffies_64_to_clock_t(u64 x);
>extern u64 nsec_to_clock_t(u64 x);
># 55 "include/linux/sched.h" 2
># 1 "include/linux/rbtree.h" 1
># 100 "include/linux/rbtree.h"
>struct rb_node
>{
> unsigned long rb_parent_color;
>
>
> struct rb_node *rb_right;
> struct rb_node *rb_left;
>} __attribute__((aligned(sizeof(long))));
>
>
>struct rb_root
>{
> struct rb_node *rb_node;
>};
># 123 "include/linux/rbtree.h"
>static inline __attribute__((always_inline)) void rb_set_parent(struct rb_node *rb, struct rb_node *p)
>{
> rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
>}
>static inline __attribute__((always_inline)) void rb_set_color(struct rb_node *rb, int color)
>{
> rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
>}
># 139 "include/linux/rbtree.h"
>extern void rb_insert_color(struct rb_node *, struct rb_root *);
>extern void rb_erase(struct rb_node *, struct rb_root *);
>
>
>extern struct rb_node *rb_next(struct rb_node *);
>extern struct rb_node *rb_prev(struct rb_node *);
>extern struct rb_node *rb_first(struct rb_root *);
>extern struct rb_node *rb_last(struct rb_root *);
>
>
>extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
>       struct rb_root *root);
>
>static inline __attribute__((always_inline)) void rb_link_node(struct rb_node * node, struct rb_node * parent,
>    struct rb_node ** rb_link)
>{
> node->rb_parent_color = (unsigned long )parent;
> node->rb_left = node->rb_right = ((void *)0);
>
> *rb_link = node;
>}
># 56 "include/linux/sched.h" 2
>
>
>
>
># 1 "include/linux/mm_types.h" 1
>
>
>
># 1 "include/linux/auxvec.h" 1
># 5 "include/linux/mm_types.h" 2
>
>
>
>
># 1 "include/linux/prio_tree.h" 1
># 14 "include/linux/prio_tree.h"
>struct raw_prio_tree_node {
> struct prio_tree_node *left;
> struct prio_tree_node *right;
> struct prio_tree_node *parent;
>};
>
>struct prio_tree_node {
> struct prio_tree_node *left;
> struct prio_tree_node *right;
> struct prio_tree_node *parent;
> unsigned long start;
> unsigned long last;
>};
>
>struct prio_tree_root {
> struct prio_tree_node *prio_tree_node;
> unsigned short index_bits;
> unsigned short raw;
>
>
>
>
>};
>
>struct prio_tree_iter {
> struct prio_tree_node *cur;
> unsigned long mask;
> unsigned long value;
> int size_level;
>
> struct prio_tree_root *root;
> unsigned long r_index;
> unsigned long h_index;
>};
>
>static inline __attribute__((always_inline)) void prio_tree_iter_init(struct prio_tree_iter *iter,
>  struct prio_tree_root *root, unsigned long r_index, unsigned long h_index)
>{
> iter->root = root;
> iter->r_index = r_index;
> iter->h_index = h_index;
> iter->cur = ((void *)0);
>}
># 84 "include/linux/prio_tree.h"
>static inline __attribute__((always_inline)) int prio_tree_empty(const struct prio_tree_root *root)
>{
> return root->prio_tree_node == ((void *)0);
>}
>
>static inline __attribute__((always_inline)) int prio_tree_root(const struct prio_tree_node *node)
>{
> return node->parent == node;
>}
>
>static inline __attribute__((always_inline)) int prio_tree_left_empty(const struct prio_tree_node *node)
>{
> return node->left == node;
>}
>
>static inline __attribute__((always_inline)) int prio_tree_right_empty(const struct prio_tree_node *node)
>{
> return node->right == node;
>}
>
>
>struct prio_tree_node *prio_tree_replace(struct prio_tree_root *root,
>                struct prio_tree_node *old, struct prio_tree_node *node);
>struct prio_tree_node *prio_tree_insert(struct prio_tree_root *root,
>                struct prio_tree_node *node);
>void prio_tree_remove(struct prio_tree_root *root, struct prio_tree_node *node);
>struct prio_tree_node *prio_tree_next(struct prio_tree_iter *iter);
># 10 "include/linux/mm_types.h" 2
>
>
># 1 "include/linux/completion.h" 1
># 13 "include/linux/completion.h"
>struct completion {
> unsigned int done;
> wait_queue_head_t wait;
>};
># 39 "include/linux/completion.h"
>static inline __attribute__((always_inline)) void init_completion(struct completion *x)
>{
> x->done = 0;
> init_waitqueue_head(&x->wait);
>}
>
>extern void wait_for_completion(struct completion *);
>extern int wait_for_completion_interruptible(struct completion *x);
>extern unsigned long wait_for_completion_timeout(struct completion *x,
>         unsigned long timeout);
>extern unsigned long wait_for_completion_interruptible_timeout(
>   struct completion *x, unsigned long timeout);
>
>extern void complete(struct completion *);
>extern void complete_all(struct completion *);
># 13 "include/linux/mm_types.h" 2
># 1 "include/asm/page.h" 1
># 14 "include/linux/mm_types.h" 2
>
>
>
>
>
>
>
>struct address_space;
>
>
>typedef atomic_long_t mm_counter_t;
># 36 "include/linux/mm_types.h"
>struct page {
> unsigned long flags;
>
> atomic_t _count;
> union {
>  atomic_t _mapcount;
>
>
>
>  unsigned int inuse;
> };
> union {
>     struct {
>  unsigned long private;
>
>
>
>
>
>
>  struct address_space *mapping;
>
>
>
>
>
>
>     };
>
>     spinlock_t ptl;
>
>     struct kmem_cache *slab;
>     struct page *first_page;
> };
> union {
>  unsigned long index;
>  void *freelist;
> };
> struct list_head lru;
># 91 "include/linux/mm_types.h"
>};
>
>
>
>
>
>
>
>struct vm_area_struct {
> struct mm_struct * vm_mm;
> unsigned long vm_start;
> unsigned long vm_end;
>
>
>
> struct vm_area_struct *vm_next;
>
> pgprot_t vm_page_prot;
> unsigned long vm_flags;
>
> struct rb_node vm_rb;
>
>
>
>
>
>
>
> union {
>  struct {
>   struct list_head list;
>   void *parent;
>   struct vm_area_struct *head;
>  } vm_set;
>
>  struct raw_prio_tree_node prio_tree_node;
> } shared;
>
>
>
>
>
>
>
> struct list_head anon_vma_node;
> struct anon_vma *anon_vma;
>
>
> struct vm_operations_struct * vm_ops;
>
>
> unsigned long vm_pgoff;
>
> struct file * vm_file;
> void * vm_private_data;
> unsigned long vm_truncate_count;
>
>
>
>
>
>
>
>};
>
>struct mm_struct {
> struct vm_area_struct * mmap;
> struct rb_root mm_rb;
> struct vm_area_struct * mmap_cache;
> unsigned long (*get_unmapped_area) (struct file *filp,
>    unsigned long addr, unsigned long len,
>    unsigned long pgoff, unsigned long flags);
> void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
> unsigned long mmap_base;
> unsigned long task_size;
> unsigned long cached_hole_size;
> unsigned long free_area_cache;
> pgd_t * pgd;
> atomic_t mm_users;
> atomic_t mm_count;
> int map_count;
> struct rw_semaphore mmap_sem;
> spinlock_t page_table_lock;
>
> struct list_head mmlist;
>
>
>
>
>
>
>
> mm_counter_t _file_rss;
> mm_counter_t _anon_rss;
>
> unsigned long hiwater_rss;
> unsigned long hiwater_vm;
>
> unsigned long total_vm, locked_vm, shared_vm, exec_vm;
> unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
> unsigned long start_code, end_code, start_data, end_data;
> unsigned long start_brk, brk, start_stack;
> unsigned long arg_start, arg_end, env_start, env_end;
>
> unsigned long saved_auxv[(2*(2 + (14 + 2) + 1))];
>
> cpumask_t cpu_vm_mask;
>
>
> mm_context_t context;
># 209 "include/linux/mm_types.h"
> unsigned int faultstamp;
> unsigned int token_priority;
> unsigned int last_interval;
>
> unsigned long flags;
>
>
> int core_waiters;
> struct completion *core_startup_done, core_done;
>
>
> rwlock_t ioctx_list_lock;
> struct kioctx *ioctx_list;
>};
># 61 "include/linux/sched.h" 2
>
># 1 "include/asm/system.h" 1
># 63 "include/linux/sched.h" 2
># 1 "include/asm/semaphore.h" 1
># 64 "include/linux/sched.h" 2
># 1 "include/asm/page.h" 1
># 65 "include/linux/sched.h" 2
>
># 1 "include/asm/cputime.h" 1
># 1 "include/asm-generic/cputime.h" 1
>
>
>
>
>
>
>typedef unsigned long cputime_t;
># 23 "include/asm-generic/cputime.h"
>typedef u64 cputime64_t;
># 1 "include/asm/cputime.h" 2
># 67 "include/linux/sched.h" 2
>
>
># 1 "include/linux/sem.h" 1
>
>
>
># 1 "include/linux/ipc.h" 1
># 9 "include/linux/ipc.h"
>struct ipc_perm
>{
> __kernel_key_t key;
> __kernel_uid_t uid;
> __kernel_gid_t gid;
> __kernel_uid_t cuid;
> __kernel_gid_t cgid;
> __kernel_mode_t mode;
> unsigned short seq;
>};
>
>
># 1 "include/asm/ipcbuf.h" 1
># 14 "include/asm/ipcbuf.h"
>struct ipc64_perm
>{
> __kernel_key_t key;
> __kernel_uid32_t uid;
> __kernel_gid32_t gid;
> __kernel_uid32_t cuid;
> __kernel_gid32_t cgid;
> __kernel_mode_t mode;
> unsigned short __pad1;
> unsigned short seq;
> unsigned short __pad2;
> unsigned long __unused1;
> unsigned long __unused2;
>};
># 22 "include/linux/ipc.h" 2
># 57 "include/linux/ipc.h"
>struct ipc_kludge {
> struct msgbuf *msgp;
> long msgtyp;
>};
># 88 "include/linux/ipc.h"
>struct kern_ipc_perm
>{
> spinlock_t lock;
> int deleted;
> int id;
> key_t key;
> uid_t uid;
> gid_t gid;
> uid_t cuid;
> gid_t cgid;
> mode_t mode;
> unsigned long seq;
> void *security;
>};
>
>struct ipc_ids;
>struct ipc_namespace {
> struct kref kref;
> struct ipc_ids *ids[3];
>
> int sem_ctls[4];
> int used_sems;
>
> int msg_ctlmax;
> int msg_ctlmnb;
> int msg_ctlmni;
> atomic_t msg_bytes;
> atomic_t msg_hdrs;
>
> size_t shm_ctlmax;
> size_t shm_ctlall;
> int shm_ctlmni;
> int shm_tot;
>};
>
>extern struct ipc_namespace init_ipc_ns;
>
>
>
>extern void free_ipc_ns(struct kref *kref);
>extern struct ipc_namespace *copy_ipcs(unsigned long flags,
>      struct ipc_namespace *ns);
># 139 "include/linux/ipc.h"
>static inline __attribute__((always_inline)) struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
>{
>
> if (ns)
>  kref_get(&ns->kref);
>
> return ns;
>}
>
>static inline __attribute__((always_inline)) void put_ipc_ns(struct ipc_namespace *ns)
>{
>
> kref_put(&ns->kref, free_ipc_ns);
>
>}
># 5 "include/linux/sem.h" 2
># 23 "include/linux/sem.h"
>struct semid_ds {
> struct ipc_perm sem_perm;
> __kernel_time_t sem_otime;
> __kernel_time_t sem_ctime;
> struct sem *sem_base;
> struct sem_queue *sem_pending;
> struct sem_queue **sem_pending_last;
> struct sem_undo *undo;
> unsigned short sem_nsems;
>};
>
>
># 1 "include/asm/sembuf.h" 1
># 13 "include/asm/sembuf.h"
>struct semid64_ds {
> struct ipc64_perm sem_perm;
> __kernel_time_t sem_otime;
> unsigned long __unused1;
> __kernel_time_t sem_ctime;
> unsigned long __unused2;
> unsigned long sem_nsems;
> unsigned long __unused3;
> unsigned long __unused4;
>};
># 36 "include/linux/sem.h" 2
>
>
>struct sembuf {
> unsigned short sem_num;
> short sem_op;
> short sem_flg;
>};
>
>
>union semun {
> int val;
> struct semid_ds *buf;
> unsigned short *array;
> struct seminfo *__buf;
> void *__pad;
>};
>
>struct seminfo {
> int semmap;
> int semmni;
> int semmns;
> int semmnu;
> int semmsl;
> int semopm;
> int semume;
> int semusz;
> int semvmx;
> int semaem;
>};
># 80 "include/linux/sem.h"
># 1 "include/asm/atomic.h" 1
># 81 "include/linux/sem.h" 2
>
>struct task_struct;
>
>
>struct sem {
> int semval;
> int sempid;
>};
>
>
>struct sem_array {
> struct kern_ipc_perm sem_perm;
> time_t sem_otime;
> time_t sem_ctime;
> struct sem *sem_base;
> struct sem_queue *sem_pending;
> struct sem_queue **sem_pending_last;
> struct sem_undo *undo;
> unsigned long sem_nsems;
>};
>
>
>struct sem_queue {
> struct sem_queue * next;
> struct sem_queue ** prev;
> struct task_struct* sleeper;
> struct sem_undo * undo;
> int pid;
> int status;
> struct sem_array * sma;
> int id;
> struct sembuf * sops;
> int nsops;
> int alter;
>};
>
>
>
>
>struct sem_undo {
> struct sem_undo * proc_next;
> struct sem_undo * id_next;
> int semid;
> short * semadj;
>};
>
>
>
>
>struct sem_undo_list {
> atomic_t refcnt;
> spinlock_t lock;
> struct sem_undo *proc_list;
>};
>
>struct sysv_sem {
> struct sem_undo_list *undo_list;
>};
>
>
>
>extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
>extern void exit_sem(struct task_struct *tsk);
># 70 "include/linux/sched.h" 2
># 1 "include/linux/signal.h" 1
>
>
>
># 1 "include/asm/signal.h" 1
># 10 "include/asm/signal.h"
>struct siginfo;
># 28 "include/asm/signal.h"
>typedef unsigned long old_sigset_t;
>
>typedef struct {
> unsigned long sig[(64 / 32)];
>} sigset_t;
># 120 "include/asm/signal.h"
># 1 "include/asm-generic/signal.h" 1
># 17 "include/asm-generic/signal.h"
>typedef void __signalfn_t(int);
>typedef __signalfn_t *__sighandler_t;
>
>typedef void __restorefn_t(void);
>typedef __restorefn_t *__sigrestore_t;
># 121 "include/asm/signal.h" 2
>
>
>
>
>
>struct old_sigaction {
> __sighandler_t sa_handler;
> old_sigset_t sa_mask;
> unsigned long sa_flags;
> __sigrestore_t sa_restorer;
>};
>
>struct sigaction {
> __sighandler_t sa_handler;
> unsigned long sa_flags;
> __sigrestore_t sa_restorer;
> sigset_t sa_mask;
>};
>
>struct k_sigaction {
> struct sigaction sa;
>};
># 175 "include/asm/signal.h"
>typedef struct sigaltstack {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
>} stack_t;
># 5 "include/linux/signal.h" 2
># 1 "include/asm/siginfo.h" 1
>
>
>
>
>
>
>
># 1 "include/asm-generic/siginfo.h" 1
>
>
>
>
>
>
>typedef union sigval {
> int sival_int;
> void *sival_ptr;
>} sigval_t;
># 40 "include/asm-generic/siginfo.h"
>typedef struct siginfo {
> int si_signo;
> int si_errno;
> int si_code;
>
> union {
>  int _pad[((128 - (3 * sizeof(int))) / sizeof(int))];
>
>
>  struct {
>   pid_t _pid;
>   uid_t _uid;
>  } _kill;
>
>
>  struct {
>   timer_t _tid;
>   int _overrun;
>   char _pad[sizeof( uid_t) - sizeof(int)];
>   sigval_t _sigval;
>   int _sys_private;
>  } _timer;
>
>
>  struct {
>   pid_t _pid;
>   uid_t _uid;
>   sigval_t _sigval;
>  } _rt;
>
>
>  struct {
>   pid_t _pid;
>   uid_t _uid;
>   int _status;
>   clock_t _utime;
>   clock_t _stime;
>  } _sigchld;
>
>
>  struct {
>   void *_addr;
>
>
>
>  } _sigfault;
>
>
>  struct {
>   long _band;
>   int _fd;
>  } _sigpoll;
> } _sifields;
>} siginfo_t;
># 251 "include/asm-generic/siginfo.h"
>typedef struct sigevent {
> sigval_t sigev_value;
> int sigev_signo;
> int sigev_notify;
> union {
>  int _pad[((64 - (sizeof(int) * 2 + sizeof(sigval_t))) / sizeof(int))];
>   int _tid;
>
>  struct {
>   void (*_function)(sigval_t);
>   void *_attribute;
>  } _sigev_thread;
> } _sigev_un;
>} sigevent_t;
>
>
>
>
>
>
>
>struct siginfo;
>void do_schedule_next_timer(struct siginfo *info);
>
>
>
>
>
>static inline __attribute__((always_inline)) void copy_siginfo(struct siginfo *to, struct siginfo *from)
>{
> if (from->si_code < 0)
>  (__builtin_constant_p(sizeof(*to)) ? __constant_memcpy((to),(from),(sizeof(*to))) : __memcpy((to),(from),(sizeof(*to))));
> else
>
>  (__builtin_constant_p((3 * sizeof(int)) + sizeof(from->_sifields._sigchld)) ? __constant_memcpy((to),(from),((3 * sizeof(int)) + sizeof(from->_sifields._sigchld))) : __memcpy((to),(from),((3 * sizeof(int)) + sizeof(from->_sifields._sigchld))));
>}
>
>
>
>extern int copy_siginfo_to_user(struct siginfo *to, struct siginfo *from);
># 9 "include/asm/siginfo.h" 2
># 6 "include/linux/signal.h" 2
># 14 "include/linux/signal.h"
>struct sigqueue {
> struct list_head list;
> int flags;
> siginfo_t info;
> struct user_struct *user;
>};
>
>
>
>
>struct sigpending {
> struct list_head list;
> sigset_t signal;
>};
># 38 "include/linux/signal.h"
>static inline __attribute__((always_inline)) void sigaddset(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 32) == 1)
>  set->sig[0] |= 1UL << sig;
> else
>  set->sig[sig / 32] |= 1UL << (sig % 32);
>}
>
>static inline __attribute__((always_inline)) void sigdelset(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 32) == 1)
>  set->sig[0] &= ~(1UL << sig);
> else
>  set->sig[sig / 32] &= ~(1UL << (sig % 32));
>}
>
>static inline __attribute__((always_inline)) int sigismember(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 32) == 1)
>  return 1 & (set->sig[0] >> sig);
> else
>  return 1 & (set->sig[sig / 32] >> (sig % 32));
>}
>
>static inline __attribute__((always_inline)) int sigfindinword(unsigned long word)
>{
> return ffz(~word);
>}
>
>
>
>static inline __attribute__((always_inline)) int sigisemptyset(sigset_t *set)
>{
> extern void _NSIG_WORDS_is_unsupported_size(void);
> switch ((64 / 32)) {
> case 4:
>  return (set->sig[3] | set->sig[2] |
>   set->sig[1] | set->sig[0]) == 0;
> case 2:
>  return (set->sig[1] | set->sig[0]) == 0;
> case 1:
>  return set->sig[0] == 0;
> default:
>  _NSIG_WORDS_is_unsupported_size();
>  return 0;
> }
>}
># 119 "include/linux/signal.h"
>static inline __attribute__((always_inline)) void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 32)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) | (b3)); r->sig[2] = ((a2) | (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) | (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) | (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
>
>
>static inline __attribute__((always_inline)) void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 32)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & (b3)); r->sig[2] = ((a2) & (b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & (b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & (b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
>
>
>static inline __attribute__((always_inline)) void signandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { extern void _NSIG_WORDS_is_unsupported_size(void); unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 32)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & ~(b3)); r->sig[2] = ((a2) & ~(b2)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & ~(b1)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & ~(b0)); break; default: _NSIG_WORDS_is_unsupported_size(); } }
># 149 "include/linux/signal.h"
>static inline __attribute__((always_inline)) void signotset(sigset_t *set) { extern void _NSIG_WORDS_is_unsupported_size(void); switch ((64 / 32)) { case 4: set->sig[3] = (~(set->sig[3])); set->sig[2] = (~(set->sig[2])); case 2: set->sig[1] = (~(set->sig[1])); case 1: set->sig[0] = (~(set->sig[0])); break; default: _NSIG_WORDS_is_unsupported_size(); } }
>
>
>
>
>static inline __attribute__((always_inline)) void sigemptyset(sigset_t *set)
>{
> switch ((64 / 32)) {
> default:
>  (__builtin_constant_p(0) ? (__builtin_constant_p((sizeof(sigset_t))) ? __constant_c_and_count_memset(((set)),((0x01010101UL*(unsigned char)(0))),((sizeof(sigset_t)))) : __constant_c_memset(((set)),((0x01010101UL*(unsigned char)(0))),((sizeof(sigset_t))))) : (__builtin_constant_p((sizeof(sigset_t))) ? __memset_generic((((set))),(((0))),(((sizeof(sigset_t))))) : __memset_generic(((set)),((0)),((sizeof(sigset_t))))));
>  break;
> case 2: set->sig[1] = 0;
> case 1: set->sig[0] = 0;
>  break;
> }
>}
>
>static inline __attribute__((always_inline)) void sigfillset(sigset_t *set)
>{
> switch ((64 / 32)) {
> default:
>  (__builtin_constant_p(-1) ? (__builtin_constant_p((sizeof(sigset_t))) ? __constant_c_and_count_memset(((set)),((0x01010101UL*(unsigned char)(-1))),((sizeof(sigset_t)))) : __constant_c_memset(((set)),((0x01010101UL*(unsigned char)(-1))),((sizeof(sigset_t))))) : (__builtin_constant_p((sizeof(sigset_t))) ? __memset_generic((((set))),(((-1))),(((sizeof(sigset_t))))) : __memset_generic(((set)),((-1)),((sizeof(sigset_t))))));
>  break;
> case 2: set->sig[1] = -1;
> case 1: set->sig[0] = -1;
>  break;
> }
>}
>
>
>
>static inline __attribute__((always_inline)) void sigaddsetmask(sigset_t *set, unsigned long mask)
>{
> set->sig[0] |= mask;
>}
>
>static inline __attribute__((always_inline)) void sigdelsetmask(sigset_t *set, unsigned long mask)
>{
> set->sig[0] &= ~mask;
>}
>
>static inline __attribute__((always_inline)) int sigtestsetmask(sigset_t *set, unsigned long mask)
>{
> return (set->sig[0] & mask) != 0;
>}
>
>static inline __attribute__((always_inline)) void siginitset(sigset_t *set, unsigned long mask)
>{
> set->sig[0] = mask;
> switch ((64 / 32)) {
> default:
>  (__builtin_constant_p(0) ? (__builtin_constant_p((sizeof(long)*((64 / 32)-1))) ? __constant_c_and_count_memset(((&set->sig[1])),((0x01010101UL*(unsigned char)(0))),((sizeof(long)*((64 / 32)-1)))) : __constant_c_memset(((&set->sig[1])),((0x01010101UL*(unsigned char)(0))),((sizeof(long)*((64 / 32)-1))))) : (__builtin_constant_p((sizeof(long)*((64 / 32)-1))) ? __memset_generic((((&set->sig[1]))),(((0))),(((sizeof(long)*((64 / 32)-1))))) : __memset_generic(((&set->sig[1])),((0)),((sizeof(long)*((64 / 32)-1))))));
>  break;
> case 2: set->sig[1] = 0;
> case 1: ;
> }
>}
>
>static inline __attribute__((always_inline)) void siginitsetinv(sigset_t *set, unsigned long mask)
>{
> set->sig[0] = ~mask;
> switch ((64 / 32)) {
> default:
>  (__builtin_constant_p(-1) ? (__builtin_constant_p((sizeof(long)*((64 / 32)-1))) ? __constant_c_and_count_memset(((&set->sig[1])),((0x01010101UL*(unsigned char)(-1))),((sizeof(long)*((64 / 32)-1)))) : __constant_c_memset(((&set->sig[1])),((0x01010101UL*(unsigned char)(-1))),((sizeof(long)*((64 / 32)-1))))) : (__builtin_constant_p((sizeof(long)*((64 / 32)-1))) ? __memset_generic((((&set->sig[1]))),(((-1))),(((sizeof(long)*((64 / 32)-1))))) : __memset_generic(((&set->sig[1])),((-1)),((sizeof(long)*((64 / 32)-1))))));
>  break;
> case 2: set->sig[1] = -1;
> case 1: ;
> }
>}
>
>
>
>static inline __attribute__((always_inline)) void init_sigpending(struct sigpending *sig)
>{
> sigemptyset(&sig->signal);
> INIT_LIST_HEAD(&sig->list);
>}
>
>extern void flush_sigqueue(struct sigpending *queue);
>
>
>static inline __attribute__((always_inline)) int valid_signal(unsigned long sig)
>{
> return sig <= 64 ? 1 : 0;
>}
>
>extern int next_signal(struct sigpending *pending, sigset_t *mask);
>extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
>extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
>extern long do_sigpending(void *, unsigned long);
>extern int sigprocmask(int, sigset_t *, sigset_t *);
>extern int show_unhandled_signals;
>
>struct pt_regs;
>extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
>
>extern struct kmem_cache *sighand_cachep;
>
>int unhandled_signal(struct task_struct *tsk, int sig);
># 71 "include/linux/sched.h" 2
># 1 "include/linux/securebits.h" 1
>
>
>
>
>
>extern unsigned securebits;
># 72 "include/linux/sched.h" 2
># 1 "include/linux/fs_struct.h" 1
>
>
>
>struct dentry;
>struct vfsmount;
>
>struct fs_struct {
> atomic_t count;
> rwlock_t lock;
> int umask;
> struct dentry * root, * pwd, * altroot;
> struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
>};
>
>
>
>
>
>
>
>extern struct kmem_cache *fs_cachep;
>
>extern void exit_fs(struct task_struct *);
>extern void set_fs_altroot(void);
>extern void set_fs_root(struct fs_struct *, struct vfsmount *, struct dentry *);
>extern void set_fs_pwd(struct fs_struct *, struct vfsmount *, struct dentry *);
>extern struct fs_struct *copy_fs_struct(struct fs_struct *);
>extern void put_fs_struct(struct fs_struct *);
># 73 "include/linux/sched.h" 2
>
>
># 1 "include/linux/pid.h" 1
>
>
>
># 1 "include/linux/rcupdate.h" 1
># 51 "include/linux/rcupdate.h"
>struct rcu_head {
> struct rcu_head *next;
> void (*func)(struct rcu_head *head);
>};
># 65 "include/linux/rcupdate.h"
>struct rcu_ctrlblk {
> long cur;
> long completed;
> int next_pending;
>
> int signaled;
>
> spinlock_t lock __attribute__((__aligned__(1 << ((7)))));
> cpumask_t cpumask;
>
>} __attribute__((__aligned__(1 << ((7)))));
>
>
>static inline __attribute__((always_inline)) int rcu_batch_before(long a, long b)
>{
>        return (a - b) < 0;
>}
>
>
>static inline __attribute__((always_inline)) int rcu_batch_after(long a, long b)
>{
>        return (a - b) > 0;
>}
>
>
>
>
>
>
>struct rcu_data {
>
> long quiescbatch;
> int passed_quiesc;
> int qs_pending;
>
>
> long batch;
> struct rcu_head *nxtlist;
> struct rcu_head **nxttail;
> long qlen;
> struct rcu_head *curlist;
> struct rcu_head **curtail;
> struct rcu_head *donelist;
> struct rcu_head **donetail;
> long blimit;
> int cpu;
> struct rcu_head barrier;
>};
>
>extern __typeof__(struct rcu_data) per_cpu__rcu_data;
>extern __typeof__(struct rcu_data) per_cpu__rcu_bh_data;
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void rcu_qsctr_inc(int cpu)
>{
> struct rcu_data *rdp = &(*({ extern int simple_indentifier_rcu_data(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__rcu_data)); (typeof(&per_cpu__rcu_data)) (__ptr + (__per_cpu_offset[cpu])); }); }));
> rdp->passed_quiesc = 1;
>}
>static inline __attribute__((always_inline)) void rcu_bh_qsctr_inc(int cpu)
>{
> struct rcu_data *rdp = &(*({ extern int simple_indentifier_rcu_bh_data(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__rcu_bh_data)); (typeof(&per_cpu__rcu_bh_data)) (__ptr + (__per_cpu_offset[cpu])); }); }));
> rdp->passed_quiesc = 1;
>}
>
>extern int rcu_pending(int cpu);
>extern int rcu_needs_cpu(int cpu);
># 298 "include/linux/rcupdate.h"
>extern void rcu_init(void);
>extern void rcu_check_callbacks(int cpu, int user);
>extern void rcu_restart_cpu(int cpu);
>extern long rcu_batches_completed(void);
>extern long rcu_batches_completed_bh(void);
>
>
>extern void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *head)) __attribute__((regparm(3)));
>
>extern void call_rcu_bh(struct rcu_head *head, void (*func)(struct rcu_head *head)) __attribute__((regparm(3)));
>
>extern void synchronize_rcu(void);
>extern void rcu_barrier(void);
># 5 "include/linux/pid.h" 2
>
>enum pid_type
>{
> PIDTYPE_PID,
> PIDTYPE_PGID,
> PIDTYPE_SID,
> PIDTYPE_MAX
>};
># 50 "include/linux/pid.h"
>struct upid {
>
> int nr;
> struct pid_namespace *ns;
> struct hlist_node pid_chain;
>};
>
>struct pid
>{
> atomic_t count;
>
> struct hlist_head tasks[PIDTYPE_MAX];
> struct rcu_head rcu;
> int level;
> struct upid numbers[1];
>};
>
>extern struct pid init_struct_pid;
>
>struct pid_link
>{
> struct hlist_node node;
> struct pid *pid;
>};
>
>static inline __attribute__((always_inline)) struct pid *get_pid(struct pid *pid)
>{
> if (pid)
>  atomic_inc(&pid->count);
> return pid;
>}
>
>extern void put_pid(struct pid *pid) __attribute__((regparm(3)));
>extern struct task_struct *pid_task(struct pid *pid, enum pid_type) __attribute__((regparm(3)));
>extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type) __attribute__((regparm(3)));
>
>
>extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
>
>
>
>
>
>extern int attach_pid(struct task_struct *task, enum pid_type type, struct pid *pid) __attribute__((regparm(3)));
>
>extern void detach_pid(struct task_struct *task, enum pid_type) __attribute__((regparm(3)));
>extern void transfer_pid(struct task_struct *old, struct task_struct *new, enum pid_type) __attribute__((regparm(3)));
>
>
>struct pid_namespace;
>extern struct pid_namespace init_pid_ns;
># 112 "include/linux/pid.h"
>extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns) __attribute__((regparm(3)));
>extern struct pid *find_vpid(int nr);
>extern struct pid *find_pid(int nr);
>
>
>
>
>extern struct pid *find_get_pid(int nr);
>extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
>
>extern struct pid *alloc_pid(struct pid_namespace *ns);
>extern void free_pid(struct pid *pid) __attribute__((regparm(3)));
>extern void zap_pid_ns_processes(struct pid_namespace *pid_ns);
># 138 "include/linux/pid.h"
>static inline __attribute__((always_inline)) pid_t pid_nr(struct pid *pid)
>{
> pid_t nr = 0;
> if (pid)
>  nr = pid->numbers[0].nr;
> return nr;
>}
>
>pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t pid_vnr(struct pid *pid)
>{
> pid_t nr = 0;
> if (pid)
>  nr = pid->numbers[pid->level].nr;
> return nr;
>}
># 76 "include/linux/sched.h" 2
>
>
># 1 "include/linux/proportions.h" 1
># 12 "include/linux/proportions.h"
># 1 "include/linux/percpu_counter.h" 1
># 18 "include/linux/percpu_counter.h"
>struct percpu_counter {
> spinlock_t lock;
> s64 count;
>
> struct list_head list;
>
> s32 *counters;
>};
>
>
>
>
>
>
>
>int percpu_counter_init(struct percpu_counter *fbc, s64 amount);
>int percpu_counter_init_irq(struct percpu_counter *fbc, s64 amount);
>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);
>
>static inline __attribute__((always_inline)) void percpu_counter_add(struct percpu_counter *fbc, s64 amount)
>{
> __percpu_counter_add(fbc, amount, (32*2));
>}
>
>static inline __attribute__((always_inline)) 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)) s64 percpu_counter_sum(struct percpu_counter *fbc)
>{
> return __percpu_counter_sum(fbc);
>}
>
>static inline __attribute__((always_inline)) s64 percpu_counter_read(struct percpu_counter *fbc)
>{
> return fbc->count;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) s64 percpu_counter_read_positive(struct percpu_counter *fbc)
>{
> s64 ret = fbc->count;
>
> __asm__ __volatile__("": : :"memory");
> if (ret >= 0)
>  return ret;
> return 1;
>}
># 132 "include/linux/percpu_counter.h"
>static inline __attribute__((always_inline)) void percpu_counter_inc(struct percpu_counter *fbc)
>{
> percpu_counter_add(fbc, 1);
>}
>
>static inline __attribute__((always_inline)) void percpu_counter_dec(struct percpu_counter *fbc)
>{
> percpu_counter_add(fbc, -1);
>}
>
>static inline __attribute__((always_inline)) void percpu_counter_sub(struct percpu_counter *fbc, s64 amount)
>{
> percpu_counter_add(fbc, -amount);
>}
># 13 "include/linux/proportions.h" 2
>
>
>
>struct prop_global {
>
>
>
>
>
> int shift;
>
>
>
>
>
>
> struct percpu_counter events;
>};
>
>
>
>
>
>
>struct prop_descriptor {
> int index;
> struct prop_global pg[2];
> struct mutex mutex;
>};
>
>int prop_descriptor_init(struct prop_descriptor *pd, int shift);
>void prop_change_shift(struct prop_descriptor *pd, int new_shift);
>
>
>
>
>
>struct prop_local_percpu {
>
>
>
> struct percpu_counter events;
>
>
>
>
> int shift;
> unsigned long period;
> spinlock_t lock;
>};
>
>int prop_local_init_percpu(struct prop_local_percpu *pl);
>void prop_local_destroy_percpu(struct prop_local_percpu *pl);
>void __prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl);
>void prop_fraction_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl,
>  long *numerator, long *denominator);
>
>static inline __attribute__((always_inline))
>void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)
>{
> unsigned long flags;
>
> do { do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
> __prop_inc_percpu(pd, pl);
> do { if (raw_irqs_disabled_flags(flags)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
>}
>
>
>
>
>
>struct prop_local_single {
>
>
>
> unsigned long events;
>
>
>
>
>
> int shift;
> unsigned long period;
> spinlock_t lock;
>};
>
>
>
>
>
>int prop_local_init_single(struct prop_local_single *pl);
>void prop_local_destroy_single(struct prop_local_single *pl);
>void __prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl);
>void prop_fraction_single(struct prop_descriptor *pd, struct prop_local_single *pl,
>  long *numerator, long *denominator);
>
>static inline __attribute__((always_inline))
>void prop_inc_single(struct prop_descriptor *pd, struct prop_local_single *pl)
>{
> unsigned long flags;
>
> do { do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
> __prop_inc_single(pd, pl);
> do { if (raw_irqs_disabled_flags(flags)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
>}
># 79 "include/linux/sched.h" 2
># 1 "include/linux/seccomp.h" 1
># 24 "include/linux/seccomp.h"
>typedef struct { } seccomp_t;
>
>
>
>static inline __attribute__((always_inline)) long prctl_get_seccomp(void)
>{
> return -22;
>}
>
>static inline __attribute__((always_inline)) long prctl_set_seccomp(unsigned long arg2)
>{
> return -22;
>}
># 80 "include/linux/sched.h" 2
>
># 1 "include/linux/futex.h" 1
>
>
>
># 1 "include/linux/sched.h" 1
># 5 "include/linux/futex.h" 2
>
>union ktime;
># 47 "include/linux/futex.h"
>struct robust_list {
> struct robust_list *next;
>};
># 59 "include/linux/futex.h"
>struct robust_list_head {
>
>
>
> struct robust_list list;
>
>
>
>
>
>
>
> long futex_offset;
># 83 "include/linux/futex.h"
> struct robust_list *list_op_pending;
>};
># 111 "include/linux/futex.h"
>long do_futex(u32 *uaddr, int op, u32 val, union ktime *timeout,
>       u32 *uaddr2, u32 val2, u32 val3);
>
>extern int
>handle_futex_death(u32 *uaddr, struct task_struct *curr, int pi);
># 135 "include/linux/futex.h"
>union futex_key {
> struct {
>  unsigned long pgoff;
>  struct inode *inode;
>  int offset;
> } shared;
> struct {
>  unsigned long address;
>  struct mm_struct *mm;
>  int offset;
> } private;
> struct {
>  unsigned long word;
>  void *ptr;
>  int offset;
> } both;
>};
>
>
>extern void exit_robust_list(struct task_struct *curr);
>extern void exit_pi_state_list(struct task_struct *curr);
># 82 "include/linux/sched.h" 2
># 1 "include/linux/rtmutex.h" 1
># 16 "include/linux/rtmutex.h"
># 1 "include/linux/plist.h" 1
># 80 "include/linux/plist.h"
>struct plist_head {
> struct list_head prio_list;
> struct list_head node_list;
>
>
>
>};
>
>struct plist_node {
> int prio;
> struct plist_head plist;
>};
># 127 "include/linux/plist.h"
>static inline __attribute__((always_inline)) void
>plist_head_init(struct plist_head *head, spinlock_t *lock)
>{
> INIT_LIST_HEAD(&head->prio_list);
> INIT_LIST_HEAD(&head->node_list);
>
>
>
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void plist_node_init(struct plist_node *node, int prio)
>{
> node->prio = prio;
> plist_head_init(&node->plist, ((void *)0));
>}
>
>extern void plist_add(struct plist_node *node, struct plist_head *head);
>extern void plist_del(struct plist_node *node, struct plist_head *head);
># 195 "include/linux/plist.h"
>static inline __attribute__((always_inline)) int plist_head_empty(const struct plist_head *head)
>{
> return list_empty(&head->node_list);
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int plist_node_empty(const struct plist_node *node)
>{
> return plist_head_empty(&node->plist);
>}
># 234 "include/linux/plist.h"
>static inline __attribute__((always_inline)) struct plist_node* plist_first(const struct plist_head *head)
>{
> return ({ const typeof( ((struct plist_node *)0)->plist.node_list ) *__mptr = (head->node_list.next); (struct plist_node *)( (char *)__mptr - __builtin_offsetof(struct plist_node,plist.node_list) );});
>
>}
># 17 "include/linux/rtmutex.h" 2
># 26 "include/linux/rtmutex.h"
>struct rt_mutex {
> spinlock_t wait_lock;
> struct plist_head wait_list;
> struct task_struct *owner;
>
>
>
>
>
>
>};
>
>struct rt_mutex_waiter;
>struct hrtimer_sleeper;
>
>
>
>
>
>
> static inline __attribute__((always_inline)) int rt_mutex_debug_check_no_locks_freed(const void *from,
>             unsigned long len)
> {
> return 0;
> }
># 80 "include/linux/rtmutex.h"
>static inline __attribute__((always_inline)) int rt_mutex_is_locked(struct rt_mutex *lock)
>{
> return lock->owner != ((void *)0);
>}
>
>extern void __rt_mutex_init(struct rt_mutex *lock, const char *name);
>extern void rt_mutex_destroy(struct rt_mutex *lock);
>
>extern void rt_mutex_lock(struct rt_mutex *lock);
>extern int rt_mutex_lock_interruptible(struct rt_mutex *lock,
>      int detect_deadlock);
>extern int rt_mutex_timed_lock(struct rt_mutex *lock,
>     struct hrtimer_sleeper *timeout,
>     int detect_deadlock);
>
>extern int rt_mutex_trylock(struct rt_mutex *lock);
>
>extern void rt_mutex_unlock(struct rt_mutex *lock);
># 83 "include/linux/sched.h" 2
>
>
># 1 "include/linux/param.h" 1
># 86 "include/linux/sched.h" 2
># 1 "include/linux/resource.h" 1
>
>
>
>
>
>struct task_struct;
># 23 "include/linux/resource.h"
>struct rusage {
> struct timeval ru_utime;
> struct timeval ru_stime;
> long ru_maxrss;
> long ru_ixrss;
> long ru_idrss;
> long ru_isrss;
> long ru_minflt;
> long ru_majflt;
> long ru_nswap;
> long ru_inblock;
> long ru_oublock;
> long ru_msgsnd;
> long ru_msgrcv;
> long ru_nsignals;
> long ru_nvcsw;
> long ru_nivcsw;
>};
>
>struct rlimit {
> unsigned long rlim_cur;
> unsigned long rlim_max;
>};
># 70 "include/linux/resource.h"
># 1 "include/asm/resource.h" 1
># 1 "include/asm-generic/resource.h" 1
># 1 "include/asm/resource.h" 2
># 71 "include/linux/resource.h" 2
>
>int getrusage(struct task_struct *p, int who, struct rusage *ru);
># 87 "include/linux/sched.h" 2
># 1 "include/linux/timer.h" 1
>
>
>
>
># 1 "include/linux/ktime.h" 1
># 46 "include/linux/ktime.h"
>union ktime {
> s64 tv64;
># 57 "include/linux/ktime.h"
>};
>
>typedef union ktime ktime_t;
># 81 "include/linux/ktime.h"
>static inline __attribute__((always_inline)) ktime_t ktime_set(const long secs, const unsigned long nsecs)
>{
>
>
>
>
> return (ktime_t) { .tv64 = (s64)secs * 1000000000L + (s64)nsecs };
>}
># 113 "include/linux/ktime.h"
>static inline __attribute__((always_inline)) ktime_t timespec_to_ktime(struct timespec ts)
>{
> return ktime_set(ts.tv_sec, ts.tv_nsec);
>}
>
>
>static inline __attribute__((always_inline)) ktime_t timeval_to_ktime(struct timeval tv)
>{
> return ktime_set(tv.tv_sec, tv.tv_usec * 1000L);
>}
># 287 "include/linux/ktime.h"
>static inline __attribute__((always_inline)) int ktime_equal(const ktime_t cmp1, const ktime_t cmp2)
>{
> return cmp1.tv64 == cmp2.tv64;
>}
>
>static inline __attribute__((always_inline)) s64 ktime_to_us(const ktime_t kt)
>{
> struct timeval tv = ns_to_timeval((kt).tv64);
> return (s64) tv.tv_sec * 1000000L + tv.tv_usec;
>}
>
>static inline __attribute__((always_inline)) s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
>{
>       return ktime_to_us(({ (ktime_t){ .tv64 = (later).tv64 - (earlier).tv64 }; }));
>}
>
>static inline __attribute__((always_inline)) ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
>{
> return ({ (ktime_t){ .tv64 = (kt).tv64 + (usec * 1000) }; });
>}
>
>static inline __attribute__((always_inline)) ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
>{
> return ({ (ktime_t){ .tv64 = (kt).tv64 - (usec * 1000) }; });
>}
># 322 "include/linux/ktime.h"
>extern void ktime_get_ts(struct timespec *ts);
># 6 "include/linux/timer.h" 2
>
>
>struct tvec_t_base_s;
>
>struct timer_list {
> struct list_head entry;
> unsigned long expires;
>
> void (*function)(unsigned long);
> unsigned long data;
>
> struct tvec_t_base_s *base;
>
>
>
>
>
>};
>
>extern struct tvec_t_base_s boot_tvec_bases;
># 38 "include/linux/timer.h"
>void __attribute__((regparm(3))) init_timer(struct timer_list * timer);
>void __attribute__((regparm(3))) init_timer_deferrable(struct timer_list *timer);
>
>static inline __attribute__((always_inline)) void setup_timer(struct timer_list * timer,
>    void (*function)(unsigned long),
>    unsigned long data)
>{
> timer->function = function;
> timer->data = data;
> init_timer(timer);
>}
># 60 "include/linux/timer.h"
>static inline __attribute__((always_inline)) int timer_pending(const struct timer_list * timer)
>{
> return timer->entry.next != ((void *)0);
>}
>
>extern void add_timer_on(struct timer_list *timer, int cpu);
>extern int del_timer(struct timer_list * timer);
>extern int __mod_timer(struct timer_list *timer, unsigned long expires);
>extern int mod_timer(struct timer_list *timer, unsigned long expires);
># 80 "include/linux/timer.h"
>extern unsigned long next_timer_interrupt(void);
>
>
>
>
>
>extern unsigned long get_next_timer_interrupt(unsigned long now);
># 114 "include/linux/timer.h"
>static inline __attribute__((always_inline)) void init_timer_stats(void)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_timer_set_start_info(struct timer_list *timer)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_timer_clear_start_info(struct timer_list *timer)
>{
>}
>
>
>extern void delayed_work_timer_fn(unsigned long __data);
># 143 "include/linux/timer.h"
>static inline __attribute__((always_inline)) void add_timer(struct timer_list *timer)
>{
> do { if (__builtin_expect(!!(timer_pending(timer)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("include/linux/timer.h"), "i" (145), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
> __mod_timer(timer, timer->expires);
>}
>
>
>  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);
># 88 "include/linux/sched.h" 2
># 1 "include/linux/hrtimer.h" 1
># 24 "include/linux/hrtimer.h"
>struct hrtimer_clock_base;
>struct hrtimer_cpu_base;
>
>
>
>
>enum hrtimer_mode {
> HRTIMER_MODE_ABS,
> HRTIMER_MODE_REL,
>};
>
>
>
>
>enum hrtimer_restart {
> HRTIMER_NORESTART,
> HRTIMER_RESTART,
>};
># 53 "include/linux/hrtimer.h"
>enum hrtimer_cb_mode {
> HRTIMER_CB_SOFTIRQ,
> HRTIMER_CB_IRQSAFE,
> HRTIMER_CB_IRQSAFE_NO_RESTART,
> HRTIMER_CB_IRQSAFE_NO_SOFTIRQ,
>};
># 112 "include/linux/hrtimer.h"
>struct hrtimer {
> struct rb_node node;
> ktime_t expires;
> enum hrtimer_restart (*function)(struct hrtimer *);
> struct hrtimer_clock_base *base;
> unsigned long state;
>
> enum hrtimer_cb_mode cb_mode;
> struct list_head cb_entry;
>
>
>
>
>
>
>};
># 136 "include/linux/hrtimer.h"
>struct hrtimer_sleeper {
> struct hrtimer timer;
> struct task_struct *task;
>};
># 156 "include/linux/hrtimer.h"
>struct hrtimer_clock_base {
> struct hrtimer_cpu_base *cpu_base;
> clockid_t index;
> struct rb_root active;
> struct rb_node *first;
> ktime_t resolution;
> ktime_t (*get_time)(void);
> ktime_t (*get_softirq_time)(void);
> ktime_t softirq_time;
>
> ktime_t offset;
> int (*reprogram)(struct hrtimer *t,
>          struct hrtimer_clock_base *b,
>          ktime_t n);
>
>};
># 193 "include/linux/hrtimer.h"
>struct hrtimer_cpu_base {
> spinlock_t lock;
> struct lock_class_key lock_key;
> struct hrtimer_clock_base clock_base[2];
>
> ktime_t expires_next;
> int hres_active;
> struct list_head cb_pending;
> unsigned long nr_events;
>
>};
>
>
>struct clock_event_device;
>
>extern void clock_was_set(void);
>extern void hres_timers_resume(void);
>extern void hrtimer_interrupt(struct clock_event_device *dev);
>
>
>
>
>static inline __attribute__((always_inline)) ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
>{
> return timer->base->get_time();
>}
># 253 "include/linux/hrtimer.h"
>extern ktime_t ktime_get(void);
>extern ktime_t ktime_get_real(void);
>
>
>
>
>extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
>    enum hrtimer_mode mode);
>
>
>extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
>    const enum hrtimer_mode mode);
>extern int hrtimer_cancel(struct hrtimer *timer);
>extern int hrtimer_try_to_cancel(struct hrtimer *timer);
>
>static inline __attribute__((always_inline)) int hrtimer_restart(struct hrtimer *timer)
>{
> return hrtimer_start(timer, timer->expires, HRTIMER_MODE_ABS);
>}
>
>
>extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
>extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
>
>extern ktime_t hrtimer_get_next_event(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_active(const struct hrtimer *timer)
>{
> return timer->state != 0x00;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_is_queued(struct hrtimer *timer)
>{
> return timer->state &
>  (0x01 | 0x04);
>}
>
>
>extern unsigned long
>hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
>
>
>extern long hrtimer_nanosleep(struct timespec *rqtp,
>         struct timespec *rmtp,
>         const enum hrtimer_mode mode,
>         const clockid_t clockid);
>extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);
>
>extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
>     struct task_struct *tsk);
>
>
>extern void hrtimer_run_queues(void);
>
>
>extern void __attribute__ ((__section__ (".init.text"))) hrtimers_init(void);
>
>
>extern unsigned long ktime_divns(const ktime_t kt, s64 div);
>
>
>
>
>
>extern void sysrq_timer_list_show(void);
># 354 "include/linux/hrtimer.h"
>static inline __attribute__((always_inline)) void timer_stats_account_hrtimer(struct hrtimer *timer)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
>{
>}
>
>static inline __attribute__((always_inline)) void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
>{
>}
># 89 "include/linux/sched.h" 2
># 1 "include/linux/task_io_accounting.h" 1
># 12 "include/linux/task_io_accounting.h"
>struct task_io_accounting {
>
>
>
>
> u64 read_bytes;
>
>
>
>
>
> u64 write_bytes;
># 32 "include/linux/task_io_accounting.h"
> u64 cancelled_write_bytes;
>};
># 90 "include/linux/sched.h" 2
>
>
># 1 "include/asm/processor.h" 1
># 93 "include/linux/sched.h" 2
>
>struct exec_domain;
>struct futex_pi_state;
>struct bio;
># 114 "include/linux/sched.h"
>extern unsigned long avenrun[];
># 128 "include/linux/sched.h"
>extern unsigned long total_forks;
>extern int nr_threads;
>extern __typeof__(unsigned long) per_cpu__process_counts;
>extern int nr_processes(void);
>extern unsigned long nr_running(void);
>extern unsigned long nr_uninterruptible(void);
>extern unsigned long nr_active(void);
>extern unsigned long nr_iowait(void);
>extern unsigned long weighted_cpuload(const int cpu);
>
>struct seq_file;
>struct cfs_rq;
>struct task_group;
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>proc_sched_show_task(struct task_struct *p, struct seq_file *m)
>{
>}
>static inline __attribute__((always_inline)) void proc_sched_set_task(struct task_struct *p)
>{
>}
>static inline __attribute__((always_inline)) void
>print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
>{
>}
># 213 "include/linux/sched.h"
>extern rwlock_t tasklist_lock;
>extern spinlock_t mmlist_lock;
>
>struct task_struct;
>
>extern void sched_init(void);
>extern void sched_init_smp(void);
>extern void init_idle(struct task_struct *idle, int cpu);
>extern void init_idle_bootup_task(struct task_struct *idle);
>
>extern cpumask_t nohz_cpu_mask;
>
>
>
>static inline __attribute__((always_inline)) int select_nohz_load_balancer(int cpu)
>{
> return 0;
>}
>
>
>
>
>
>extern void show_state_filter(unsigned long state_filter);
>
>static inline __attribute__((always_inline)) void show_state(void)
>{
> show_state_filter(0);
>}
>
>extern void show_regs(struct pt_regs *);
>
>
>
>
>
>
>extern void show_stack(struct task_struct *task, unsigned long *sp);
>
>void io_schedule(void);
>long io_schedule_timeout(long timeout);
>
>extern void cpu_init (void);
>extern void trap_init(void);
>extern void account_process_tick(struct task_struct *task, int user);
>extern void update_process_times(int user);
>extern void scheduler_tick(void);
>
>
>extern void softlockup_tick(void);
>extern void spawn_softlockup_task(void);
>extern void touch_softlockup_watchdog(void);
>extern void touch_all_softlockup_watchdogs(void);
>extern int softlockup_thresh;
># 287 "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) __attribute__((regparm(3)));
>extern signed long schedule_timeout_interruptible(signed long timeout);
>extern signed long schedule_timeout_uninterruptible(signed long timeout);
> __attribute__((regparm(0))) void schedule(void);
>
>struct nsproxy;
>struct user_namespace;
>
>
>
>
>extern int sysctl_max_map_count;
>
># 1 "include/linux/aio.h" 1
>
>
>
>
># 1 "include/linux/workqueue.h" 1
># 12 "include/linux/workqueue.h"
># 1 "include/asm/atomic.h" 1
># 13 "include/linux/workqueue.h" 2
>
>struct workqueue_struct;
>
>struct work_struct;
>typedef void (*work_func_t)(struct work_struct *work);
>
>
>
>
>
>
>
>struct work_struct {
> atomic_long_t data;
>
>
>
> struct list_head entry;
> work_func_t func;
>
>
>
>};
>
>
>
>struct delayed_work {
> struct work_struct work;
> struct timer_list timer;
>};
>
>struct execute_work {
> struct work_struct work;
>};
># 150 "include/linux/workqueue.h"
>extern struct workqueue_struct *
>__create_workqueue_key(const char *name, int singlethread,
>         int freezeable, struct lock_class_key *key);
># 171 "include/linux/workqueue.h"
>extern void destroy_workqueue(struct workqueue_struct *wq);
>
>extern int queue_work(struct workqueue_struct *wq, struct work_struct *work) __attribute__((regparm(3)));
>extern int queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay) __attribute__((regparm(3)));
>
>extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
>   struct delayed_work *work, unsigned long delay);
>
>extern void flush_workqueue(struct workqueue_struct *wq) __attribute__((regparm(3)));
>extern void flush_scheduled_work(void);
>
>extern int schedule_work(struct work_struct *work) __attribute__((regparm(3)));
>extern int schedule_delayed_work(struct delayed_work *work, unsigned long delay) __attribute__((regparm(3)));
>
>extern int schedule_delayed_work_on(int cpu, struct delayed_work *work,
>     unsigned long delay);
>extern int schedule_on_each_cpu(work_func_t func);
>extern int current_is_keventd(void);
>extern int keventd_up(void);
>
>extern void init_workqueues(void);
>int execute_in_process_context(work_func_t fn, struct execute_work *);
>
>extern int cancel_work_sync(struct work_struct *work);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int cancel_delayed_work(struct delayed_work *work)
>{
> int ret;
>
> ret = del_timer_sync(&work->timer);
> if (ret)
>  clear_bit(0, ((unsigned long *)(&(&work->work)->data)));
> return ret;
>}
>
>extern int cancel_delayed_work_sync(struct delayed_work *work);
>
>
>static inline __attribute__((always_inline))
>void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
>     struct delayed_work *work)
>{
> cancel_delayed_work_sync(work);
>}
>
>
>static inline __attribute__((always_inline))
>void cancel_rearming_delayed_work(struct delayed_work *work)
>{
> cancel_delayed_work_sync(work);
>}
># 6 "include/linux/aio.h" 2
># 1 "include/linux/aio_abi.h" 1
># 32 "include/linux/aio_abi.h"
>typedef unsigned long aio_context_t;
>
>enum {
> IOCB_CMD_PREAD = 0,
> IOCB_CMD_PWRITE = 1,
> IOCB_CMD_FSYNC = 2,
> IOCB_CMD_FDSYNC = 3,
>
>
>
>
> IOCB_CMD_NOOP = 6,
> IOCB_CMD_PREADV = 7,
> IOCB_CMD_PWRITEV = 8,
>};
># 57 "include/linux/aio_abi.h"
>struct io_event {
> __u64 data;
> __u64 obj;
> __s64 res;
> __s64 res2;
>};
># 78 "include/linux/aio_abi.h"
>struct iocb {
>
> __u64 aio_data;
> __u32 aio_key, aio_reserved1;
>
>
>
> __u16 aio_lio_opcode;
> __s16 aio_reqprio;
> __u32 aio_fildes;
>
> __u64 aio_buf;
> __u64 aio_nbytes;
> __s64 aio_offset;
>
>
> __u64 aio_reserved2;
>
>
> __u32 aio_flags;
>
>
>
>
>
> __u32 aio_resfd;
>};
># 7 "include/linux/aio.h" 2
># 1 "include/linux/uio.h" 1
># 16 "include/linux/uio.h"
>struct iovec
>{
> void *iov_base;
> __kernel_size_t iov_len;
>};
>
>
>
>struct kvec {
> void *iov_base;
> size_t iov_len;
>};
># 45 "include/linux/uio.h"
>static inline __attribute__((always_inline)) size_t iov_length(const struct iovec *iov, unsigned long nr_segs)
>{
> unsigned long seg;
> size_t ret = 0;
>
> for (seg = 0; seg < nr_segs; seg++)
>  ret += iov[seg].iov_len;
> return ret;
>}
>
>unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to);
># 8 "include/linux/aio.h" 2
>
># 1 "include/asm/atomic.h" 1
># 10 "include/linux/aio.h" 2
>
>
>
>
>
>struct kioctx;
># 87 "include/linux/aio.h"
>struct kiocb {
> struct list_head ki_run_list;
> unsigned long ki_flags;
> int ki_users;
> unsigned ki_key;
>
> struct file *ki_filp;
> struct kioctx *ki_ctx;
> int (*ki_cancel)(struct kiocb *, struct io_event *);
> ssize_t (*ki_retry)(struct kiocb *);
> void (*ki_dtor)(struct kiocb *);
>
> union {
>  void *user;
>  struct task_struct *tsk;
> } ki_obj;
>
> __u64 ki_user_data;
> wait_queue_t ki_wait;
> loff_t ki_pos;
>
> atomic_t ki_bio_count;
> void *private;
>
> unsigned short ki_opcode;
> size_t ki_nbytes;
> char *ki_buf;
> size_t ki_left;
> struct iovec ki_inline_vec;
>  struct iovec *ki_iovec;
>  unsigned long ki_nr_segs;
>  unsigned long ki_cur_seg;
>
> struct list_head ki_list;
>
>
>
>
>
>
> struct file *ki_eventfd;
>};
># 150 "include/linux/aio.h"
>struct aio_ring {
> unsigned id;
> unsigned nr;
> unsigned head;
> unsigned tail;
>
> unsigned magic;
> unsigned compat_features;
> unsigned incompat_features;
> unsigned header_length;
>
>
> struct io_event io_events[0];
>};
>
>
>
>
>struct aio_ring_info {
> unsigned long mmap_base;
> unsigned long mmap_size;
>
> struct page **ring_pages;
> spinlock_t ring_lock;
> long nr_pages;
>
> unsigned nr, tail;
>
> struct page *internal_pages[8];
>};
>
>struct kioctx {
> atomic_t users;
> int dead;
> struct mm_struct *mm;
>
>
> unsigned long user_id;
> struct kioctx *next;
>
> wait_queue_head_t wait;
>
> spinlock_t ctx_lock;
>
> int reqs_active;
> struct list_head active_reqs;
> struct list_head run_list;
>
>
> unsigned max_reqs;
>
> struct aio_ring_info ring_info;
>
> struct delayed_work wq;
>};
>
>
>extern unsigned aio_max_size;
>
>extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb) __attribute__((regparm(3)));
>extern int aio_put_req(struct kiocb *iocb) __attribute__((regparm(3)));
>extern void kick_iocb(struct kiocb *iocb) __attribute__((regparm(3)));
>extern int aio_complete(struct kiocb *iocb, long res, long res2) __attribute__((regparm(3)));
>extern void __put_ioctx(struct kioctx *ctx) __attribute__((regparm(3)));
>struct mm_struct;
>extern void exit_aio(struct mm_struct *mm) __attribute__((regparm(3)));
>extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
>extern int io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, struct iocb *iocb) __attribute__((regparm(3)));
>
>
>
>struct kioctx *lookup_ioctx(unsigned long ctx_id);
>int io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, struct iocb *iocb) __attribute__((regparm(3)));
># 239 "include/linux/aio.h"
>static inline __attribute__((always_inline)) struct kiocb *list_kiocb(struct list_head *h)
>{
> return ({ const typeof( ((struct kiocb *)0)->ki_list ) *__mptr = (h); (struct kiocb *)( (char *)__mptr - __builtin_offsetof(struct kiocb,ki_list) );});
>}
>
>
>extern unsigned long aio_nr;
>extern unsigned long aio_max_nr;
># 307 "include/linux/sched.h" 2
>
>extern unsigned long
>arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
>         unsigned long, unsigned long);
>extern unsigned long
>arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
>     unsigned long len, unsigned long pgoff,
>     unsigned long flags);
>extern void arch_unmap_area(struct mm_struct *, unsigned long);
>extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
># 354 "include/linux/sched.h"
>extern void set_dumpable(struct mm_struct *mm, int value);
>extern int get_dumpable(struct mm_struct *mm);
># 376 "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;
>};
># 398 "include/linux/sched.h"
>struct signal_struct {
> atomic_t count;
> atomic_t live;
>
> wait_queue_head_t wait_chldexit;
>
>
> struct task_struct *curr_target;
>
>
> struct sigpending shared_pending;
>
>
> int group_exit_code;
>
>
>
>
>
> struct task_struct *group_exit_task;
> int notify_count;
>
>
> int group_stop_count;
> unsigned int flags;
>
>
> struct list_head posix_timers;
>
>
> struct hrtimer real_timer;
> struct task_struct *tsk;
> ktime_t it_real_incr;
>
>
> cputime_t it_prof_expires, it_virt_expires;
> cputime_t it_prof_incr, it_virt_incr;
># 443 "include/linux/sched.h"
> union {
>  pid_t pgrp __attribute__((deprecated));
>  pid_t __pgrp;
> };
>
> struct pid *tty_old_pgrp;
>
> union {
>  pid_t session __attribute__((deprecated));
>  pid_t __session;
> };
>
>
> int leader;
>
> struct tty_struct *tty;
>
>
>
>
>
>
>
> cputime_t utime, stime, cutime, cstime;
> cputime_t gtime;
> cputime_t cgtime;
> unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
> unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
> unsigned long inblock, oublock, cinblock, coublock;
>
>
>
>
>
>
>
> unsigned long long sum_sched_runtime;
># 490 "include/linux/sched.h"
> struct rlimit rlim[15];
>
> struct list_head cpu_timers[3];
>
>
>
>
> struct key *session_keyring;
> struct key *process_keyring;
>
>
>
>
>
> struct taskstats *stats;
>
>
> unsigned audit_tty;
> struct tty_audit_buf *tty_audit_buf;
>
>};
># 528 "include/linux/sched.h"
>struct user_struct {
> atomic_t __count;
> atomic_t processes;
> atomic_t files;
> atomic_t sigpending;
>
> atomic_t inotify_watches;
> atomic_t inotify_devs;
>
>
>
> unsigned long mq_bytes;
>
> unsigned long locked_shm;
>
>
> struct key *uid_keyring;
> struct key *session_keyring;
>
>
>
> struct hlist_node uidhash_node;
> uid_t uid;
>
>
> struct task_group *tg;
>
> struct kset kset;
> struct subsys_attribute user_attr;
> struct work_struct work;
>
>
>};
>
>
>extern int uids_kobject_init(void);
>
>
>
>
>extern struct user_struct *find_user(uid_t);
>
>extern struct user_struct root_user;
>
>
>struct backing_dev_info;
>struct reclaim_state;
>
>
>struct sched_info {
>
> unsigned long pcount;
> unsigned long long cpu_time,
>      run_delay;
>
>
> unsigned long long last_arrival,
>      last_queued;
>
>
> unsigned int bkl_count;
>
>};
>
>
>
>extern const struct file_operations proc_schedstat_operations;
>
>
>
>struct task_delay_info {
> spinlock_t lock;
> unsigned int flags;
># 617 "include/linux/sched.h"
> struct timespec blkio_start, blkio_end;
> u64 blkio_delay;
> u64 swapin_delay;
> u32 blkio_count;
>
> u32 swapin_count;
>
>};
>
>
>static inline __attribute__((always_inline)) int sched_info_on(void)
>{
>
> return 1;
>
>
>
>
>
>
>}
>
>enum cpu_idle_type {
> CPU_IDLE,
> CPU_NOT_IDLE,
> CPU_NEWLY_IDLE,
> CPU_MAX_IDLE_TYPES
>};
># 682 "include/linux/sched.h"
>struct sched_group {
> struct sched_group *next;
> cpumask_t cpumask;
>
>
>
>
>
>
> unsigned int __cpu_power;
>
>
>
>
> u32 reciprocal_cpu_power;
>};
>
>struct sched_domain {
>
> struct sched_domain *parent;
> struct sched_domain *child;
> struct sched_group *groups;
> cpumask_t span;
> 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;
> int flags;
>
>
> unsigned long last_balance;
> unsigned int balance_interval;
> unsigned int nr_balance_failed;
>
>
>
> unsigned int lb_count[CPU_MAX_IDLE_TYPES];
> unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
> unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
> unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
> unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
> unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
> unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
> unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
>
>
> unsigned int alb_count;
> unsigned int alb_failed;
> unsigned int alb_pushed;
>
>
> unsigned int sbe_count;
> unsigned int sbe_balanced;
> unsigned int sbe_pushed;
>
>
> unsigned int sbf_count;
> unsigned int sbf_balanced;
> unsigned int sbf_pushed;
>
>
> unsigned int ttwu_wake_remote;
> unsigned int ttwu_move_affine;
> unsigned int ttwu_move_balance;
>
>};
>
>extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new);
># 765 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int above_background_load(void)
>{
> unsigned long cpu;
>
> for (((cpu)) = __first_cpu(&(cpu_online_map)); ((cpu)) < 32; ((cpu)) = __next_cpu((((cpu))), &((cpu_online_map)))) {
>  if (weighted_cpuload(cpu) >= (1L << 10))
>   return 1;
> }
> return 0;
>}
>
>struct io_context;
>
>
>struct group_info {
> int ngroups;
> atomic_t usage;
> gid_t small_block[32];
> int nblocks;
> gid_t *blocks[0];
>};
># 802 "include/linux/sched.h"
>extern struct group_info *groups_alloc(int gidsetsize);
>extern void groups_free(struct group_info *group_info);
>extern int set_current_groups(struct group_info *group_info);
>extern int groups_search(struct group_info *group_info, gid_t grp);
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void prefetch_stack(struct task_struct *t) { }
>
>
>struct audit_context;
>struct mempolicy;
>struct pipe_inode_info;
>struct uts_namespace;
>
>struct rq;
>struct sched_domain;
>
>struct sched_class {
> const struct sched_class *next;
>
> void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
> void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
> void (*yield_task) (struct rq *rq);
>
> void (*check_preempt_curr) (struct rq *rq, struct task_struct *p);
>
> struct task_struct * (*pick_next_task) (struct rq *rq);
> void (*put_prev_task) (struct rq *rq, struct task_struct *p);
>
>
> unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
>   struct rq *busiest, unsigned long max_load_move,
>   struct sched_domain *sd, enum cpu_idle_type idle,
>   int *all_pinned, int *this_best_prio);
>
> int (*move_one_task) (struct rq *this_rq, int this_cpu,
>         struct rq *busiest, struct sched_domain *sd,
>         enum cpu_idle_type idle);
>
>
> void (*set_curr_task) (struct rq *rq);
> void (*task_tick) (struct rq *rq, struct task_struct *p);
> void (*task_new) (struct rq *rq, struct task_struct *p);
>};
>
>struct load_weight {
> unsigned long weight, inv_weight;
>};
># 866 "include/linux/sched.h"
>struct sched_entity {
> struct load_weight load;
> struct rb_node run_node;
> unsigned int on_rq;
>
> u64 exec_start;
> u64 sum_exec_runtime;
> u64 vruntime;
> u64 prev_sum_exec_runtime;
>
>
> u64 wait_start;
> u64 wait_max;
>
> u64 sleep_start;
> u64 sleep_max;
> s64 sum_sleep_runtime;
>
> u64 block_start;
> u64 block_max;
> u64 exec_max;
> u64 slice_max;
>
> u64 nr_migrations;
> u64 nr_migrations_cold;
> u64 nr_failed_migrations_affine;
> u64 nr_failed_migrations_running;
> u64 nr_failed_migrations_hot;
> u64 nr_forced_migrations;
> u64 nr_forced2_migrations;
>
> u64 nr_wakeups;
> u64 nr_wakeups_sync;
> u64 nr_wakeups_migrate;
> u64 nr_wakeups_local;
> u64 nr_wakeups_remote;
> u64 nr_wakeups_affine;
> u64 nr_wakeups_affine_attempts;
> u64 nr_wakeups_passive;
> u64 nr_wakeups_idle;
>
>
>
> struct sched_entity *parent;
>
> struct cfs_rq *cfs_rq;
>
> struct cfs_rq *my_q;
>
>};
>
>struct task_struct {
> volatile long state;
> void *stack;
> atomic_t usage;
> unsigned int flags;
> unsigned int ptrace;
>
> int lock_depth;
>
>
>
>
>
>
>
> int prio, static_prio, normal_prio;
> struct list_head run_list;
> const struct sched_class *sched_class;
> struct sched_entity se;
>
>
>
> struct hlist_head preempt_notifiers;
>
>
> unsigned short ioprio;
># 951 "include/linux/sched.h"
> unsigned char fpu_counter;
> s8 oomkilladj;
>
> unsigned int btrace_seq;
>
>
> unsigned int policy;
> cpumask_t cpus_allowed;
> unsigned int time_slice;
>
>
> struct sched_info sched_info;
>
>
> struct list_head tasks;
>
>
>
>
> struct list_head ptrace_children;
> struct list_head ptrace_list;
>
> struct mm_struct *mm, *active_mm;
>
>
> struct linux_binfmt *binfmt;
> int exit_state;
> int exit_code, exit_signal;
> int pdeath_signal;
>
> unsigned int personality;
> unsigned did_exec:1;
> pid_t pid;
> pid_t tgid;
># 995 "include/linux/sched.h"
> struct task_struct *real_parent;
> struct task_struct *parent;
>
>
>
>
> struct list_head children;
> struct list_head sibling;
> struct task_struct *group_leader;
>
>
> struct pid_link pids[PIDTYPE_MAX];
> struct list_head thread_group;
>
> struct completion *vfork_done;
> int *set_child_tid;
> int *clear_child_tid;
>
> unsigned int rt_priority;
> cputime_t utime, stime, utimescaled, stimescaled;
> cputime_t gtime;
> cputime_t prev_utime, prev_stime;
> unsigned long nvcsw, nivcsw;
> struct timespec start_time;
> struct timespec real_start_time;
>
> unsigned long min_flt, maj_flt;
>
>   cputime_t it_prof_expires, it_virt_expires;
> unsigned long long it_sched_expires;
> struct list_head cpu_timers[3];
>
>
> uid_t uid,euid,suid,fsuid;
> gid_t gid,egid,sgid,fsgid;
> struct group_info *group_info;
> kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
> unsigned keep_capabilities:1;
> struct user_struct *user;
>
> struct key *request_key_auth;
> struct key *thread_keyring;
> unsigned char jit_keyring;
>
> char comm[16];
>
>
>
>
> int link_count, total_link_count;
>
>
> struct sysv_sem sysvsem;
>
>
> struct thread_struct thread;
>
> struct fs_struct *fs;
>
> struct files_struct *files;
>
> struct nsproxy *nsproxy;
>
> struct signal_struct *signal;
> struct sighand_struct *sighand;
>
> sigset_t blocked, real_blocked;
> sigset_t saved_sigmask;
> struct sigpending pending;
>
> unsigned long sas_ss_sp;
> size_t sas_ss_size;
> int (*notifier)(void *priv);
> void *notifier_data;
> sigset_t *notifier_mask;
>
> void *security;
>
> struct audit_context *audit_context;
> seccomp_t seccomp;
>
>
>    u32 parent_exec_id;
>    u32 self_exec_id;
>
> spinlock_t alloc_lock;
>
>
> spinlock_t pi_lock;
>
>
>
> struct plist_head pi_waiters;
>
> struct rt_mutex_waiter *pi_blocked_on;
># 1120 "include/linux/sched.h"
> void *journal_info;
>
>
> struct bio *bio_list, **bio_tail;
>
>
> struct reclaim_state *reclaim_state;
>
> struct backing_dev_info *backing_dev_info;
>
> struct io_context *io_context;
>
> unsigned long ptrace_message;
> siginfo_t *last_siginfo;
>
>
> u64 rchar, wchar, syscr, syscw;
>
> struct task_io_accounting ioac;
>
> u64 acct_rss_mem1;
> u64 acct_vm_mem1;
> cputime_t acct_stimexpd;
># 1160 "include/linux/sched.h"
> struct robust_list_head *robust_list;
>
>
>
> struct list_head pi_state_list;
> struct futex_pi_state *pi_state_cache;
>
> atomic_t fs_excl;
> struct rcu_head rcu;
>
>
>
>
> struct pipe_inode_info *splice_pipe;
>
> struct task_delay_info *delays;
>
>
> int make_it_fail;
>
> struct prop_local_single dirties;
>};
># 1202 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int rt_prio(int prio)
>{
> if (__builtin_expect(!!(prio < 100), 0))
>  return 1;
> return 0;
>}
>
>static inline __attribute__((always_inline)) int rt_task(struct task_struct *p)
>{
> return rt_prio(p->prio);
>}
>
>static inline __attribute__((always_inline)) void set_task_session(struct task_struct *tsk, pid_t session)
>{
> tsk->signal->__session = session;
>}
>
>static inline __attribute__((always_inline)) void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
>{
> tsk->signal->__pgrp = pgrp;
>}
>
>static inline __attribute__((always_inline)) struct pid *task_pid(struct task_struct *task)
>{
> return task->pids[PIDTYPE_PID].pid;
>}
>
>static inline __attribute__((always_inline)) struct pid *task_tgid(struct task_struct *task)
>{
> return task->group_leader->pids[PIDTYPE_PID].pid;
>}
>
>static inline __attribute__((always_inline)) struct pid *task_pgrp(struct task_struct *task)
>{
> return task->group_leader->pids[PIDTYPE_PGID].pid;
>}
>
>static inline __attribute__((always_inline)) struct pid *task_session(struct task_struct *task)
>{
> return task->group_leader->pids[PIDTYPE_SID].pid;
>}
>
>struct pid_namespace;
># 1268 "include/linux/sched.h"
>static inline __attribute__((always_inline)) pid_t task_pid_nr(struct task_struct *tsk)
>{
> return tsk->pid;
>}
>
>pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_pid_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_pid(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_tgid_nr(struct task_struct *tsk)
>{
> return tsk->tgid;
>}
>
>pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_tgid_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_tgid(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_pgrp_nr(struct task_struct *tsk)
>{
> return tsk->signal->__pgrp;
>}
>
>pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_pgrp_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_pgrp(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_session_nr(struct task_struct *tsk)
>{
> return tsk->signal->__session;
>}
>
>pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
>
>static inline __attribute__((always_inline)) pid_t task_session_vnr(struct task_struct *tsk)
>{
> return pid_vnr(task_session(tsk));
>}
>
>
>static inline __attribute__((always_inline)) pid_t task_ppid_nr_ns(struct task_struct *tsk,
>  struct pid_namespace *ns)
>{
> return pid_nr_ns(task_pid(({ typeof(tsk->real_parent) _________p1 = (*(volatile typeof(tsk->real_parent) *)&(tsk->real_parent)); do { } while(0); (_________p1); })), ns);
>}
># 1334 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int pid_alive(struct task_struct *p)
>{
> return p->pids[PIDTYPE_PID].pid != ((void *)0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int is_global_init(struct task_struct *tsk)
>{
> return tsk->pid == 1;
>}
>
>
>
>
>
>extern int is_container_init(struct task_struct *tsk);
>
>extern struct pid *cad_pid;
>
>extern void free_task(struct task_struct *tsk);
>
>
>extern void __put_task_struct(struct task_struct *t);
>
>static inline __attribute__((always_inline)) void put_task_struct(struct task_struct *t)
>{
> if (atomic_dec_and_test(&t->usage))
>  __put_task_struct(t);
>}
># 1426 "include/linux/sched.h"
>extern int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask);
># 1436 "include/linux/sched.h"
>extern unsigned long long sched_clock(void);
>
>
>
>
>
>extern unsigned long long cpu_clock(int cpu);
>
>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 sched_idle_next(void);
># 1480 "include/linux/sched.h"
>extern unsigned int sysctl_sched_compat_yield;
>
>
>extern int rt_mutex_getprio(struct task_struct *p);
>extern void rt_mutex_setprio(struct task_struct *p, int prio);
>extern void rt_mutex_adjust_pi(struct task_struct *p);
># 1494 "include/linux/sched.h"
>extern void set_user_nice(struct task_struct *p, long nice);
>extern int task_prio(const struct task_struct *p);
>extern int task_nice(const struct task_struct *p);
>extern int can_nice(const struct task_struct *p, const int nice);
>extern int task_curr(const struct task_struct *p);
>extern int idle_cpu(int cpu);
>extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
>extern struct task_struct *idle_task(int cpu);
>extern struct task_struct *curr_task(int cpu);
>extern void set_curr_task(int cpu, struct task_struct *p);
>
>void yield(void);
>
>
>
>
>extern struct exec_domain default_exec_domain;
>
>union thread_union {
> struct thread_info thread_info;
> unsigned long stack[(4096)/sizeof(long)];
>};
>
>
>static inline __attribute__((always_inline)) int kstack_end(void *addr)
>{
>
>
>
> return !(((unsigned long)addr+sizeof(void*)-1) & ((4096)-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;
># 1550 "include/linux/sched.h"
>extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
>  struct pid_namespace *ns);
>
>extern struct task_struct *find_task_by_pid(pid_t nr);
>extern struct task_struct *find_task_by_vpid(pid_t nr);
>extern struct task_struct *find_task_by_pid_ns(pid_t nr,
>  struct pid_namespace *ns);
>
>extern void __set_special_pids(pid_t session, pid_t pgrp);
>
>
>extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
>static inline __attribute__((always_inline)) struct user_struct *get_uid(struct user_struct *u)
>{
> atomic_inc(&u->__count);
> return u;
>}
>extern void free_uid(struct user_struct *);
>extern void switch_uid(struct user_struct *);
>extern void release_uids(struct user_namespace *ns);
>
># 1 "include/asm/current.h" 1
># 1572 "include/linux/sched.h" 2
>
>extern void do_timer(unsigned long ticks);
>
>extern int wake_up_state(struct task_struct * tsk, unsigned int state) __attribute__((regparm(3)));
>extern int wake_up_process(struct task_struct * tsk) __attribute__((regparm(3)));
>extern void wake_up_new_task(struct task_struct * tsk, unsigned long clone_flags) __attribute__((regparm(3)));
>
>
> extern void kick_process(struct task_struct *tsk);
>
>
>
>extern void sched_fork(struct task_struct *p, int clone_flags);
>extern void sched_dead(struct task_struct *p);
>
>extern int in_group_p(gid_t);
>extern int in_egroup_p(gid_t);
>
>extern void proc_caches_init(void);
>extern void flush_signals(struct task_struct *);
>extern void ignore_signals(struct task_struct *);
>extern void flush_signal_handlers(struct task_struct *, int force_default);
>extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
>
>static inline __attribute__((always_inline)) int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
>{
> unsigned long flags;
> int ret;
>
> flags = _spin_lock_irqsave(&tsk->sighand->siglock);
> 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 send_group_sig_info(int, struct siginfo *, struct task_struct *);
>extern int force_sigsegv(int, struct task_struct *);
>extern int force_sig_info(int, struct siginfo *, struct task_struct *);
>extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
>extern int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
>extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
>extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
>extern int kill_pgrp(struct pid *pid, int sig, int priv);
>extern int kill_pid(struct pid *pid, int sig, int priv);
>extern int kill_proc_info(int, struct siginfo *, pid_t);
>extern void do_notify_parent(struct task_struct *, int);
>extern void force_sig(int, struct task_struct *);
>extern void force_sig_specific(int, struct task_struct *);
>extern int send_sig(int, struct task_struct *, int);
>extern void zap_other_threads(struct task_struct *p);
>extern int kill_proc(pid_t, int, int);
>extern struct sigqueue *sigqueue_alloc(void);
>extern void sigqueue_free(struct sigqueue *);
>extern int send_sigqueue(int, struct sigqueue *, struct task_struct *);
>extern int send_group_sigqueue(int, struct sigqueue *, struct task_struct *);
>extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
>extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);
>
>static inline __attribute__((always_inline)) int kill_cad_pid(int sig, int priv)
>{
> return kill_pid(cad_pid, sig, priv);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int is_si_special(const struct siginfo *info)
>{
> return info <= ((struct siginfo *) 2);
>}
>
>
>
>static inline __attribute__((always_inline)) int on_sig_stack(unsigned long sp)
>{
> return (sp - get_current()->sas_ss_sp < get_current()->sas_ss_size);
>}
>
>static inline __attribute__((always_inline)) int sas_ss_flags(unsigned long sp)
>{
> return (get_current()->sas_ss_size == 0 ? 2
>  : on_sig_stack(sp) ? 1 : 0);
>}
>
>
>
>
>extern struct mm_struct * mm_alloc(void);
>
>
>extern void __mmdrop(struct mm_struct *) __attribute__((regparm(3)));
>static inline __attribute__((always_inline)) void mmdrop(struct mm_struct * mm)
>{
> if (__builtin_expect(!!(atomic_dec_and_test(&mm->mm_count)), 0))
>  __mmdrop(mm);
>}
>
>
>extern void mmput(struct mm_struct *);
>
>extern struct mm_struct *get_task_mm(struct task_struct *task);
>
>extern void mm_release(struct task_struct *, struct mm_struct *);
>
>extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
>extern void flush_thread(void);
>extern void exit_thread(void);
>
>extern void exit_files(struct task_struct *);
>extern void __cleanup_signal(struct signal_struct *);
>extern void __cleanup_sighand(struct sighand_struct *);
>extern void exit_itimers(struct signal_struct *);
>
>extern void do_group_exit(int);
>
>extern void daemonize(const char *, ...);
>extern int allow_signal(int);
>extern int disallow_signal(int);
>
>extern int do_execve(char *, char * *, char * *, struct pt_regs *);
>extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int *, int *);
>struct task_struct *fork_idle(int);
>
>extern void set_task_comm(struct task_struct *tsk, char *from);
>extern void get_task_comm(char *to, struct task_struct *tsk);
>
>
>extern void wait_task_inactive(struct task_struct * p);
># 1739 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int has_group_leader_pid(struct task_struct *p)
>{
> return p->pid == p->tgid;
>}
>
>static inline __attribute__((always_inline))
>int same_thread_group(struct task_struct *p1, struct task_struct *p2)
>{
> return p1->tgid == p2->tgid;
>}
>
>static inline __attribute__((always_inline)) struct task_struct *next_thread(const struct task_struct *p)
>{
> return ({ const typeof( ((struct task_struct *)0)->thread_group ) *__mptr = (({ typeof(p->thread_group.next) _________p1 = (*(volatile typeof(p->thread_group.next) *)&(p->thread_group.next)); do { } while(0); (_________p1); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,thread_group) );});
>
>}
>
>static inline __attribute__((always_inline)) int thread_group_empty(struct task_struct *p)
>{
> return list_empty(&p->thread_group);
>}
># 1774 "include/linux/sched.h"
>static inline __attribute__((always_inline)) void task_lock(struct task_struct *p)
>{
> _spin_lock(&p->alloc_lock);
>}
>
>static inline __attribute__((always_inline)) void task_unlock(struct task_struct *p)
>{
> do {__raw_spin_unlock(&(&p->alloc_lock)->raw_lock); (void)0; } while (0);
>}
>
>extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
>       unsigned long *flags);
>
>static inline __attribute__((always_inline)) void unlock_task_sighand(struct task_struct *tsk,
>      unsigned long *flags)
>{
> _spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void setup_thread_stack(struct task_struct *p, struct task_struct *org)
>{
> *((struct thread_info *)(p)->stack) = *((struct thread_info *)(org)->stack);
> ((struct thread_info *)(p)->stack)->task = p;
>}
>
>static inline __attribute__((always_inline)) unsigned long *end_of_stack(struct task_struct *p)
>{
> return (unsigned long *)(((struct thread_info *)(p)->stack) + 1);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void set_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> set_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> clear_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_and_set_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_and_clear_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) int test_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_ti_thread_flag(((struct thread_info *)(tsk)->stack), flag);
>}
>
>static inline __attribute__((always_inline)) void set_tsk_need_resched(struct task_struct *tsk)
>{
> set_tsk_thread_flag(tsk,2);
>}
>
>static inline __attribute__((always_inline)) void clear_tsk_need_resched(struct task_struct *tsk)
>{
> clear_tsk_thread_flag(tsk,2);
>}
>
>static inline __attribute__((always_inline)) int signal_pending(struct task_struct *p)
>{
> return __builtin_expect(!!(test_tsk_thread_flag(p,1)), 0);
>}
>
>static inline __attribute__((always_inline)) int need_resched(void)
>{
> return __builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 2)), 0);
>}
># 1866 "include/linux/sched.h"
>extern int cond_resched(void);
>extern int cond_resched_lock(spinlock_t * lock);
>extern int cond_resched_softirq(void);
># 1884 "include/linux/sched.h"
>static inline __attribute__((always_inline)) int lock_need_resched(spinlock_t *lock)
>{
> if (0 || need_resched())
>  return 1;
> return 0;
>}
>
>
>
>
>
>
>
>extern void recalc_sigpending_and_wake(struct task_struct *t);
>extern void recalc_sigpending(void);
>
>extern void signal_wake_up(struct task_struct *t, int resume_stopped);
>
>
>
>
>
>
>static inline __attribute__((always_inline)) unsigned int task_cpu(const struct task_struct *p)
>{
> return ((struct thread_info *)(p)->stack)->cpu;
>}
>
>extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
># 1928 "include/linux/sched.h"
>extern void arch_pick_mmap_layout(struct mm_struct *mm);
># 1938 "include/linux/sched.h"
>extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
>extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
>
>extern int sched_mc_power_savings, sched_smt_power_savings;
>
>extern void normalize_rt_tasks(void);
>
>
>
>extern struct task_group init_task_group;
>
>extern struct task_group *sched_create_group(void);
>extern void sched_destroy_group(struct task_group *tg);
>extern void sched_move_task(struct task_struct *tsk);
>extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
>extern unsigned long sched_group_shares(struct task_group *tg);
>
>
>
>
>static inline __attribute__((always_inline)) void add_rchar(struct task_struct *tsk, ssize_t amt)
>{
> tsk->rchar += amt;
>}
>
>static inline __attribute__((always_inline)) void add_wchar(struct task_struct *tsk, ssize_t amt)
>{
> tsk->wchar += amt;
>}
>
>static inline __attribute__((always_inline)) void inc_syscr(struct task_struct *tsk)
>{
> tsk->syscr++;
>}
>
>static inline __attribute__((always_inline)) void inc_syscw(struct task_struct *tsk)
>{
> tsk->syscw++;
>}
># 1996 "include/linux/sched.h"
>void migration_init(void);
># 14 "include/asm/irq_32.h" 2
>
># 1 "include/asm-x86/mach-default/irq_vectors.h" 1
># 87 "include/asm-x86/mach-default/irq_vectors.h"
># 1 "include/asm-x86/mach-default/irq_vectors_limits.h" 1
># 88 "include/asm-x86/mach-default/irq_vectors.h" 2
># 16 "include/asm/irq_32.h" 2
># 1 "include/asm/thread_info.h" 1
># 17 "include/asm/irq_32.h" 2
>
>static __inline__ __attribute__((always_inline)) int irq_canonicalize(int irq)
>{
> return ((irq == 2) ? 9 : irq);
>}
>
>
>
>
>
>
>  extern void irq_ctx_init(int cpu);
>  extern void irq_ctx_exit(int cpu);
># 41 "include/asm/irq_32.h"
>extern void fixup_irqs(cpumask_t map);
>
>
>unsigned int do_IRQ(struct pt_regs *regs);
>void init_IRQ(void);
>void __attribute__ ((__section__ (".init.text"))) native_init_IRQ(void);
>
>
>extern unsigned long used_vectors[(((256) + (32) - 1) / (32))];
># 3 "include/asm/irq.h" 2
># 24 "include/linux/irq.h" 2
>
># 1 "include/asm/irq_regs.h" 1
>
># 1 "include/asm/irq_regs_32.h" 1
># 10 "include/asm/irq_regs_32.h"
># 1 "include/asm/percpu.h" 1
># 11 "include/asm/irq_regs_32.h" 2
>
>extern __typeof__(struct pt_regs *) per_cpu__irq_regs;
>
>static inline __attribute__((always_inline)) struct pt_regs *get_irq_regs(void)
>{
> return ({ typeof(per_cpu__irq_regs) ret__; switch (sizeof(per_cpu__irq_regs)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__irq_regs)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__irq_regs)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__irq_regs)); break; default: __bad_percpu_size(); } ret__; });
>}
>
>static inline __attribute__((always_inline)) struct pt_regs *set_irq_regs(struct pt_regs *new_regs)
>{
> struct pt_regs *old_regs;
>
> old_regs = get_irq_regs();
> do { typedef typeof(per_cpu__irq_regs) T__; if (0) { T__ tmp__; tmp__ = (new_regs); } switch (sizeof(per_cpu__irq_regs)) { case 1: asm("mov" "b %1,""%%fs:""%0" : "+m" (per_cpu__irq_regs) :"ri" ((T__)new_regs)); break; case 2: asm("mov" "w %1,""%%fs:""%0" : "+m" (per_cpu__irq_regs) :"ri" ((T__)new_regs)); break; case 4: asm("mov" "l %1,""%%fs:""%0" : "+m" (per_cpu__irq_regs) :"ri" ((T__)new_regs)); break; default: __bad_percpu_size(); } } while (0);
>
> return old_regs;
>}
># 3 "include/asm/irq_regs.h" 2
># 26 "include/linux/irq.h" 2
>
>struct irq_desc;
>typedef void __attribute__((regparm(3))) (*irq_flow_handler_t)(unsigned int irq,
>         struct irq_desc *desc);
># 73 "include/linux/irq.h"
>struct proc_dir_entry;
>struct msi_desc;
># 98 "include/linux/irq.h"
>struct irq_chip {
> const char *name;
> unsigned int (*startup)(unsigned int irq);
> void (*shutdown)(unsigned int irq);
> void (*enable)(unsigned int irq);
> void (*disable)(unsigned int irq);
>
> void (*ack)(unsigned int irq);
> void (*mask)(unsigned int irq);
> void (*mask_ack)(unsigned int irq);
> void (*unmask)(unsigned int irq);
> void (*eoi)(unsigned int irq);
>
> void (*end)(unsigned int irq);
> void (*set_affinity)(unsigned int irq, cpumask_t dest);
> int (*retrigger)(unsigned int irq);
> int (*set_type)(unsigned int irq, unsigned int flow_type);
> int (*set_wake)(unsigned int irq, unsigned int on);
># 125 "include/linux/irq.h"
> const char *typename;
>};
># 152 "include/linux/irq.h"
>struct irq_desc {
> irq_flow_handler_t handle_irq;
> struct irq_chip *chip;
> struct msi_desc *msi_desc;
> void *handler_data;
> void *chip_data;
> struct irqaction *action;
> unsigned int status;
>
> unsigned int depth;
> unsigned int wake_depth;
> unsigned int irq_count;
> unsigned int irqs_unhandled;
> unsigned long last_unhandled;
> spinlock_t lock;
>
> cpumask_t affinity;
> unsigned int cpu;
>
>
> cpumask_t pending_mask;
>
>
> struct proc_dir_entry *dir;
>
> const char *name;
>} __attribute__((__aligned__(1 << ((7)))));
>
>extern struct irq_desc irq_desc[224];
>
>
>
>
>
>typedef struct irq_chip hw_irq_controller;
>
>typedef struct irq_desc irq_desc_t;
>
>
>
>
># 1 "include/asm/hw_irq.h" 1
>
># 1 "include/asm/hw_irq_32.h" 1
># 15 "include/asm/hw_irq_32.h"
># 1 "include/linux/profile.h" 1
># 11 "include/linux/profile.h"
># 1 "include/asm/errno.h" 1
># 12 "include/linux/profile.h" 2
>
>extern int prof_on __attribute__((__section__(".data.read_mostly")));
>
>
>
>
>
>
>struct proc_dir_entry;
>struct pt_regs;
>struct notifier_block;
>
>
>void __attribute__ ((__section__ (".init.text"))) profile_init(void);
>void profile_tick(int);
>
>
>
>
>void profile_hits(int, void *ip, unsigned int nr_hits);
>
>
>
>
>static inline __attribute__((always_inline)) void profile_hit(int type, void *ip)
>{
>
>
>
> if (__builtin_expect(!!(prof_on == type), 0))
>  profile_hits(type, ip, 1);
>}
>
>
>void create_prof_cpu_mask(struct proc_dir_entry *);
>
>
>
>
>enum profile_type {
> PROFILE_TASK_EXIT,
> PROFILE_MUNMAP
>};
>
>
>
>struct task_struct;
>struct mm_struct;
>
>
>void profile_task_exit(struct task_struct * task);
>
>
>
>
>int profile_handoff_task(struct task_struct * task);
>
>
>void profile_munmap(unsigned long addr);
>
>int task_handoff_register(struct notifier_block * n);
>int task_handoff_unregister(struct notifier_block * n);
>
>int profile_event_register(enum profile_type, struct notifier_block * n);
>int profile_event_unregister(enum profile_type, struct notifier_block * n);
>
>int register_timer_hook(int (*hook)(struct pt_regs *));
>void unregister_timer_hook(int (*hook)(struct pt_regs *));
>
>struct pt_regs;
># 16 "include/asm/hw_irq_32.h" 2
># 1 "include/asm/atomic.h" 1
># 17 "include/asm/hw_irq_32.h" 2
># 1 "include/asm/irq.h" 1
># 18 "include/asm/hw_irq_32.h" 2
># 1 "include/asm/sections.h" 1
># 1 "include/asm-generic/sections.h" 1
>
>
>
>
>
>extern char _text[], _stext[], _etext[];
>extern char _data[], _sdata[], _edata[];
>extern char __bss_start[], __bss_stop[];
>extern char __init_begin[], __init_end[];
>extern char _sinittext[], _einittext[];
>extern char _sextratext[] __attribute__((weak));
>extern char _eextratext[] __attribute__((weak));
>extern char _end[];
>extern char __per_cpu_start[], __per_cpu_end[];
>extern char __kprobes_text_start[], __kprobes_text_end[];
>extern char __initdata_begin[], __initdata_end[];
>extern char __start_rodata[], __end_rodata[];
># 1 "include/asm/sections.h" 2
># 19 "include/asm/hw_irq_32.h" 2
># 29 "include/asm/hw_irq_32.h"
>extern void (*interrupt[224])(void);
>
>
>__attribute__((regparm(3))) void reschedule_interrupt(void);
>__attribute__((regparm(3))) void invalidate_interrupt(void);
>__attribute__((regparm(3))) void call_function_interrupt(void);
>
>
>
>__attribute__((regparm(3))) void apic_timer_interrupt(void);
>__attribute__((regparm(3))) void error_interrupt(void);
>__attribute__((regparm(3))) void spurious_interrupt(void);
>__attribute__((regparm(3))) void thermal_interrupt(void);
>
>
>
>void disable_8259A_irq(unsigned int irq);
>void enable_8259A_irq(unsigned int irq);
>int i8259A_irq_pending(unsigned int irq);
>void make_8259A_irq(unsigned int irq);
>void init_8259A(int aeoi);
>void send_IPI_self(int vector) __attribute__((regparm(3)));
>void init_VISWS_APIC_irqs(void);
>void setup_IO_APIC(void);
>void disable_IO_APIC(void);
>void print_IO_APIC(void);
>int IO_APIC_get_PCI_irq_vector(int bus, int slot, int fn);
>void send_IPI(int dest, int vector);
>void setup_ioapic_dest(void);
>
>extern unsigned long io_apic_irqs;
>
>extern atomic_t irq_err_count;
>extern atomic_t irq_mis_count;
># 3 "include/asm/hw_irq.h" 2
># 194 "include/linux/irq.h" 2
>
>extern int setup_irq(unsigned int irq, struct irqaction *new);
># 207 "include/linux/irq.h"
>void set_pending_irq(unsigned int irq, cpumask_t mask);
>void move_native_irq(int irq);
>void move_masked_irq(int irq);
># 231 "include/linux/irq.h"
>extern int irq_set_affinity(unsigned int irq, cpumask_t cpumask);
>extern int irq_can_set_affinity(unsigned int irq);
># 251 "include/linux/irq.h"
>static inline __attribute__((always_inline)) void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
>{
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int select_smp_affinity(unsigned int irq)
>{
> return 1;
>}
>
>
>extern int no_irq_affinity;
>
>static inline __attribute__((always_inline)) int irq_balancing_disabled(unsigned int irq)
>{
> return irq_desc[irq].status & 0x00400000;
>}
>
>
>extern int handle_IRQ_event(unsigned int irq, struct irqaction *action);
>
>
>
>
>
>extern void __attribute__((regparm(3))) handle_level_irq(unsigned int irq, struct irq_desc *desc);
>extern void __attribute__((regparm(3))) handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
>extern void __attribute__((regparm(3))) handle_edge_irq(unsigned int irq, struct irq_desc *desc);
>extern void __attribute__((regparm(3))) handle_simple_irq(unsigned int irq, struct irq_desc *desc);
>extern void __attribute__((regparm(3))) handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
>extern void __attribute__((regparm(3))) handle_bad_irq(unsigned int irq, struct irq_desc *desc);
>
>
>
>
>
>
>extern __attribute__((regparm(3))) unsigned int __do_IRQ(unsigned int irq);
># 300 "include/linux/irq.h"
>static inline __attribute__((always_inline)) void generic_handle_irq(unsigned int irq)
>{
> struct irq_desc *desc = irq_desc + irq;
>
>
>
>
> if (__builtin_expect(!!(desc->handle_irq), 1))
>  desc->handle_irq(irq, desc);
> else
>  __do_IRQ(irq);
>
>}
>
>
>extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
>      int action_ret);
>
>
>void check_irq_resend(struct irq_desc *desc, unsigned int irq);
>
>
>extern int noirqdebug_setup(char *str);
>
>
>extern int can_request_irq(unsigned int irq, unsigned long irqflags);
>
>
>extern struct irq_chip no_irq_chip;
>extern struct irq_chip dummy_irq_chip;
>
>extern void
>set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
>    irq_flow_handler_t handle);
>extern void
>set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
>         irq_flow_handler_t handle, const char *name);
>
>extern void
>__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
>    const char *name);
>
>
>
>
>static inline __attribute__((always_inline)) void
>set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
>{
> __set_irq_handler(irq, handle, 0, ((void *)0));
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>set_irq_chained_handler(unsigned int irq,
>   irq_flow_handler_t handle)
>{
> __set_irq_handler(irq, handle, 1, ((void *)0));
>}
>
>
>extern int create_irq(void);
>extern void destroy_irq(unsigned int irq);
>
>
>static inline __attribute__((always_inline)) int irq_has_action(unsigned int irq)
>{
> struct irq_desc *desc = irq_desc + irq;
> return desc->action != ((void *)0);
>}
>
>
>extern void dynamic_irq_init(unsigned int irq);
>extern void dynamic_irq_cleanup(unsigned int irq);
>
>
>extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
>extern int set_irq_data(unsigned int irq, void *data);
>extern int set_irq_chip_data(unsigned int irq, void *data);
>extern int set_irq_type(unsigned int irq, unsigned int type);
>extern int set_irq_msi(unsigned int irq, struct msi_desc *entry);
># 36 "kernel/hrtimer.c" 2
>
>
>
>
># 1 "include/linux/syscalls.h" 1
># 14 "include/linux/syscalls.h"
>struct epoll_event;
>struct iattr;
>struct inode;
>struct iocb;
>struct io_event;
>struct iovec;
>struct itimerspec;
>struct itimerval;
>struct kexec_segment;
>struct linux_dirent;
>struct linux_dirent64;
>struct list_head;
>struct msgbuf;
>struct msghdr;
>struct msqid_ds;
>struct new_utsname;
>struct nfsctl_arg;
>struct __old_kernel_stat;
>struct pollfd;
>struct rlimit;
>struct rusage;
>struct sched_param;
>struct semaphore;
>struct sembuf;
>struct shmid_ds;
>struct sockaddr;
>struct stat;
>struct stat64;
>struct statfs;
>struct statfs64;
>struct __sysctl_args;
>struct sysinfo;
>struct timespec;
>struct timeval;
>struct timex;
>struct timezone;
>struct tms;
>struct utimbuf;
>struct mq_attr;
>struct compat_stat;
>struct compat_timeval;
>struct robust_list_head;
>struct getcpu_cache;
>
>
>
>
>
>
># 1 "include/asm/semaphore.h" 1
># 64 "include/linux/syscalls.h" 2
>
>
># 1 "include/linux/quota.h" 1
># 44 "include/linux/quota.h"
>typedef __kernel_uid32_t qid_t;
>typedef __u64 qsize_t;
># 103 "include/linux/quota.h"
>struct if_dqblk {
> __u64 dqb_bhardlimit;
> __u64 dqb_bsoftlimit;
> __u64 dqb_curspace;
> __u64 dqb_ihardlimit;
> __u64 dqb_isoftlimit;
> __u64 dqb_curinodes;
> __u64 dqb_btime;
> __u64 dqb_itime;
> __u32 dqb_valid;
>};
># 124 "include/linux/quota.h"
>struct if_dqinfo {
> __u64 dqi_bgrace;
> __u64 dqi_igrace;
> __u32 dqi_flags;
> __u32 dqi_valid;
>};
># 142 "include/linux/quota.h"
>enum {
> QUOTA_NL_C_UNSPEC,
> QUOTA_NL_C_WARNING,
> __QUOTA_NL_C_MAX,
>};
>
>
>enum {
> QUOTA_NL_A_UNSPEC,
> QUOTA_NL_A_QTYPE,
> QUOTA_NL_A_EXCESS_ID,
> QUOTA_NL_A_WARNING,
> QUOTA_NL_A_DEV_MAJOR,
> QUOTA_NL_A_DEV_MINOR,
> QUOTA_NL_A_CAUSED_ID,
> __QUOTA_NL_A_MAX,
>};
># 167 "include/linux/quota.h"
># 1 "include/linux/dqblk_xfs.h" 1
># 50 "include/linux/dqblk_xfs.h"
>typedef struct fs_disk_quota {
> __s8 d_version;
> __s8 d_flags;
> __u16 d_fieldmask;
> __u32 d_id;
> __u64 d_blk_hardlimit;
> __u64 d_blk_softlimit;
> __u64 d_ino_hardlimit;
> __u64 d_ino_softlimit;
> __u64 d_bcount;
> __u64 d_icount;
> __s32 d_itimer;
>
> __s32 d_btimer;
> __u16 d_iwarns;
> __u16 d_bwarns;
> __s32 d_padding2;
> __u64 d_rtb_hardlimit;
> __u64 d_rtb_softlimit;
> __u64 d_rtbcount;
> __s32 d_rtbtimer;
> __u16 d_rtbwarns;
> __s16 d_padding3;
> char d_padding4[8];
>} fs_disk_quota_t;
># 137 "include/linux/dqblk_xfs.h"
>typedef struct fs_qfilestat {
> __u64 qfs_ino;
> __u64 qfs_nblks;
> __u32 qfs_nextents;
>} fs_qfilestat_t;
>
>typedef struct fs_quota_stat {
> __s8 qs_version;
> __u16 qs_flags;
> __s8 qs_pad;
> fs_qfilestat_t qs_uquota;
> fs_qfilestat_t qs_gquota;
> __u32 qs_incoredqs;
> __s32 qs_btimelimit;
> __s32 qs_itimelimit;
> __s32 qs_rtbtimelimit;
> __u16 qs_bwarnlimit;
> __u16 qs_iwarnlimit;
>} fs_quota_stat_t;
># 168 "include/linux/quota.h" 2
># 1 "include/linux/dqblk_v1.h" 1
># 21 "include/linux/dqblk_v1.h"
>struct v1_mem_dqinfo {
>};
># 169 "include/linux/quota.h" 2
># 1 "include/linux/dqblk_v2.h" 1
># 20 "include/linux/dqblk_v2.h"
>struct v2_mem_dqinfo {
> unsigned int dqi_blocks;
> unsigned int dqi_free_blk;
> unsigned int dqi_free_entry;
>};
># 170 "include/linux/quota.h" 2
>
>extern spinlock_t dq_data_lock;
># 183 "include/linux/quota.h"
>struct mem_dqblk {
> __u32 dqb_bhardlimit;
> __u32 dqb_bsoftlimit;
> qsize_t dqb_curspace;
> __u32 dqb_ihardlimit;
> __u32 dqb_isoftlimit;
> __u32 dqb_curinodes;
> time_t dqb_btime;
> time_t dqb_itime;
>};
>
>
>
>
>struct quota_format_type;
>
>struct mem_dqinfo {
> struct quota_format_type *dqi_format;
> struct list_head dqi_dirty_list;
> unsigned long dqi_flags;
> unsigned int dqi_bgrace;
> unsigned int dqi_igrace;
> union {
>  struct v1_mem_dqinfo v1_i;
>  struct v2_mem_dqinfo v2_i;
> } u;
>};
>
>struct super_block;
>
>
>
>
>
>extern void mark_info_dirty(struct super_block *sb, int type);
>
>
>
>
>
>
>
>struct dqstats {
> int lookups;
> int drops;
> int reads;
> int writes;
> int cache_hits;
> int allocated_dquots;
> int free_dquots;
> int syncs;
>};
>
>extern struct dqstats dqstats;
># 245 "include/linux/quota.h"
>struct dquot {
> struct hlist_node dq_hash;
> struct list_head dq_inuse;
> struct list_head dq_free;
> struct list_head dq_dirty;
> struct mutex dq_lock;
> atomic_t dq_count;
> wait_queue_head_t dq_wait_unused;
> struct super_block *dq_sb;
> unsigned int dq_id;
> loff_t dq_off;
> unsigned long dq_flags;
> short dq_type;
> struct mem_dqblk dq_dqb;
>};
>
>
>
>
>
>
>
>struct quota_format_ops {
> int (*check_quota_file)(struct super_block *sb, int type);
> int (*read_file_info)(struct super_block *sb, int type);
> int (*write_file_info)(struct super_block *sb, int type);
> int (*free_file_info)(struct super_block *sb, int type);
> int (*read_dqblk)(struct dquot *dquot);
> int (*commit_dqblk)(struct dquot *dquot);
> int (*release_dqblk)(struct dquot *dquot);
>};
>
>
>struct dquot_operations {
> int (*initialize) (struct inode *, int);
> int (*drop) (struct inode *);
> int (*alloc_space) (struct inode *, qsize_t, int);
> int (*alloc_inode) (const struct inode *, unsigned long);
> int (*free_space) (struct inode *, qsize_t);
> int (*free_inode) (const struct inode *, unsigned long);
> int (*transfer) (struct inode *, struct iattr *);
> int (*write_dquot) (struct dquot *);
> int (*acquire_dquot) (struct dquot *);
> int (*release_dquot) (struct dquot *);
> int (*mark_dirty) (struct dquot *);
> int (*write_info) (struct super_block *, int);
>};
>
>
>struct quotactl_ops {
> int (*quota_on)(struct super_block *, int, int, char *);
> int (*quota_off)(struct super_block *, int);
> int (*quota_sync)(struct super_block *, int);
> int (*get_info)(struct super_block *, int, struct if_dqinfo *);
> int (*set_info)(struct super_block *, int, struct if_dqinfo *);
> int (*get_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
> int (*set_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
> int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
> int (*set_xstate)(struct super_block *, unsigned int, int);
> int (*get_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
> int (*set_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
>};
>
>struct quota_format_type {
> int qf_fmt_id;
> struct quota_format_ops *qf_ops;
> struct module *qf_owner;
> struct quota_format_type *qf_next;
>};
>
>
>
>
>struct quota_info {
> unsigned int flags;
> struct mutex dqio_mutex;
> struct mutex dqonoff_mutex;
> struct rw_semaphore dqptr_sem;
> struct inode *files[2];
> struct mem_dqinfo info[2];
> struct quota_format_ops *ops[2];
>};
>
>
>int mark_dquot_dirty(struct dquot *dquot);
># 339 "include/linux/quota.h"
>int register_quota_format(struct quota_format_type *fmt);
>void unregister_quota_format(struct quota_format_type *fmt);
>
>struct quota_module_name {
> int qm_fmt_id;
> char *qm_mod_name;
>};
># 67 "include/linux/syscalls.h" 2
># 1 "include/linux/key.h" 1
># 22 "include/linux/key.h"
># 1 "include/asm/atomic.h" 1
># 23 "include/linux/key.h" 2
>
>
>
>
>typedef int32_t key_serial_t;
>
>
>typedef uint32_t key_perm_t;
>
>struct key;
># 70 "include/linux/key.h"
>struct seq_file;
>struct user_struct;
>struct signal_struct;
>
>struct key_type;
>struct key_owner;
>struct keyring_list;
>struct keyring_name;
># 93 "include/linux/key.h"
>typedef struct __key_reference_with_attributes *key_ref_t;
>
>static inline __attribute__((always_inline)) key_ref_t make_key_ref(const struct key *key,
>         unsigned long possession)
>{
> return (key_ref_t) ((unsigned long) key | possession);
>}
>
>static inline __attribute__((always_inline)) struct key *key_ref_to_ptr(const key_ref_t key_ref)
>{
> return (struct key *) ((unsigned long) key_ref & ~1UL);
>}
>
>static inline __attribute__((always_inline)) unsigned long is_key_possessed(const key_ref_t key_ref)
>{
> return (unsigned long) key_ref & 1UL;
>}
># 119 "include/linux/key.h"
>struct key {
> atomic_t usage;
> key_serial_t serial;
> struct rb_node serial_node;
> struct key_type *type;
> struct rw_semaphore sem;
> struct key_user *user;
> void *security;
> time_t expiry;
> uid_t uid;
> gid_t gid;
> key_perm_t perm;
> unsigned short quotalen;
> unsigned short datalen;
># 143 "include/linux/key.h"
> unsigned long flags;
># 156 "include/linux/key.h"
> char *description;
>
>
>
>
> union {
>  struct list_head link;
>  unsigned long x[2];
>  void *p[2];
> } type_data;
>
>
>
>
>
> union {
>  unsigned long value;
>  void *data;
>  struct keyring_list *subscriptions;
> } payload;
>};
>
>extern struct key *key_alloc(struct key_type *type,
>        const char *desc,
>        uid_t uid, gid_t gid,
>        struct task_struct *ctx,
>        key_perm_t perm,
>        unsigned long flags);
>
>
>
>
>
>
>extern void key_revoke(struct key *key);
>extern void key_put(struct key *key);
>
>static inline __attribute__((always_inline)) struct key *key_get(struct key *key)
>{
> if (key)
>  atomic_inc(&key->usage);
> return key;
>}
>
>static inline __attribute__((always_inline)) void key_ref_put(key_ref_t key_ref)
>{
> key_put(key_ref_to_ptr(key_ref));
>}
>
>extern struct key *request_key(struct key_type *type,
>          const char *description,
>          const char *callout_info);
>
>extern struct key *request_key_with_auxdata(struct key_type *type,
>         const char *description,
>         const char *callout_info,
>         void *aux);
>
>extern struct key *request_key_async(struct key_type *type,
>         const char *description,
>         const char *callout_info);
>
>extern struct key *request_key_async_with_auxdata(struct key_type *type,
>        const char *description,
>        const char *callout_info,
>        void *aux);
>
>extern int wait_for_key_construction(struct key *key, bool intr);
>
>extern int key_validate(struct key *key);
>
>extern key_ref_t key_create_or_update(key_ref_t keyring,
>          const char *type,
>          const char *description,
>          const void *payload,
>          size_t plen,
>          unsigned long flags);
>
>extern int key_update(key_ref_t key,
>        const void *payload,
>        size_t plen);
>
>extern int key_link(struct key *keyring,
>      struct key *key);
>
>extern int key_unlink(struct key *keyring,
>        struct key *key);
>
>extern struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
>     struct task_struct *ctx,
>     unsigned long flags,
>     struct key *dest);
>
>extern int keyring_clear(struct key *keyring);
>
>extern key_ref_t keyring_search(key_ref_t keyring,
>    struct key_type *type,
>    const char *description);
>
>extern int keyring_add_key(struct key *keyring,
>      struct key *key);
>
>extern struct key *key_lookup(key_serial_t id);
>
>
>
>
>
>
>extern struct key root_user_keyring, root_session_keyring;
>extern int alloc_uid_keyring(struct user_struct *user,
>        struct task_struct *ctx);
>extern void switch_uid_keyring(struct user_struct *new_user);
>extern int copy_keys(unsigned long clone_flags, struct task_struct *tsk);
>extern int copy_thread_group_keys(struct task_struct *tsk);
>extern void exit_keys(struct task_struct *tsk);
>extern void exit_thread_group_keys(struct signal_struct *tg);
>extern int suid_keys(struct task_struct *tsk);
>extern int exec_keys(struct task_struct *tsk);
>extern void key_fsuid_changed(struct task_struct *tsk);
>extern void key_fsgid_changed(struct task_struct *tsk);
>extern void key_init(void);
># 68 "include/linux/syscalls.h" 2
>
> __attribute__((regparm(0))) long sys_time(time_t *tloc);
> __attribute__((regparm(0))) long sys_stime(time_t *tptr);
> __attribute__((regparm(0))) long sys_gettimeofday(struct timeval *tv,
>    struct timezone *tz);
> __attribute__((regparm(0))) long sys_settimeofday(struct timeval *tv,
>    struct timezone *tz);
> __attribute__((regparm(0))) long sys_adjtimex(struct timex *txc_p);
>
> __attribute__((regparm(0))) long sys_times(struct tms *tbuf);
>
> __attribute__((regparm(0))) long sys_gettid(void);
> __attribute__((regparm(0))) long sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp);
> __attribute__((regparm(0))) unsigned long sys_alarm(unsigned int seconds);
> __attribute__((regparm(0))) long sys_getpid(void);
> __attribute__((regparm(0))) long sys_getppid(void);
> __attribute__((regparm(0))) long sys_getuid(void);
> __attribute__((regparm(0))) long sys_geteuid(void);
> __attribute__((regparm(0))) long sys_getgid(void);
> __attribute__((regparm(0))) long sys_getegid(void);
> __attribute__((regparm(0))) long sys_getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
> __attribute__((regparm(0))) long sys_getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
> __attribute__((regparm(0))) long sys_getpgid(pid_t pid);
> __attribute__((regparm(0))) long sys_getpgrp(void);
> __attribute__((regparm(0))) long sys_getsid(pid_t pid);
> __attribute__((regparm(0))) long sys_getgroups(int gidsetsize, gid_t *grouplist);
>
> __attribute__((regparm(0))) long sys_setregid(gid_t rgid, gid_t egid);
> __attribute__((regparm(0))) long sys_setgid(gid_t gid);
> __attribute__((regparm(0))) long sys_setreuid(uid_t ruid, uid_t euid);
> __attribute__((regparm(0))) long sys_setuid(uid_t uid);
> __attribute__((regparm(0))) long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid);
> __attribute__((regparm(0))) long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid);
> __attribute__((regparm(0))) long sys_setfsuid(uid_t uid);
> __attribute__((regparm(0))) long sys_setfsgid(gid_t gid);
> __attribute__((regparm(0))) long sys_setpgid(pid_t pid, pid_t pgid);
> __attribute__((regparm(0))) long sys_setsid(void);
> __attribute__((regparm(0))) long sys_setgroups(int gidsetsize, gid_t *grouplist);
>
> __attribute__((regparm(0))) long sys_acct(const char *name);
> __attribute__((regparm(0))) long sys_capget(cap_user_header_t header,
>    cap_user_data_t dataptr);
> __attribute__((regparm(0))) long sys_capset(cap_user_header_t header,
>    const cap_user_data_t data);
> __attribute__((regparm(0))) long sys_personality(u_long personality);
>
> __attribute__((regparm(0))) long sys_sigpending(old_sigset_t *set);
> __attribute__((regparm(0))) long sys_sigprocmask(int how, old_sigset_t *set,
>    old_sigset_t *oset);
> __attribute__((regparm(0))) long sys_getitimer(int which, struct itimerval *value);
> __attribute__((regparm(0))) long sys_setitimer(int which,
>    struct itimerval *value,
>    struct itimerval *ovalue);
> __attribute__((regparm(0))) long sys_timer_create(clockid_t which_clock,
>     struct sigevent *timer_event_spec,
>     timer_t * created_timer_id);
> __attribute__((regparm(0))) long sys_timer_gettime(timer_t timer_id,
>    struct itimerspec *setting);
> __attribute__((regparm(0))) long sys_timer_getoverrun(timer_t timer_id);
> __attribute__((regparm(0))) long sys_timer_settime(timer_t timer_id, int flags,
>    const struct itimerspec *new_setting,
>    struct itimerspec *old_setting);
> __attribute__((regparm(0))) long sys_timer_delete(timer_t timer_id);
> __attribute__((regparm(0))) long sys_clock_settime(clockid_t which_clock,
>    const struct timespec *tp);
> __attribute__((regparm(0))) long sys_clock_gettime(clockid_t which_clock,
>    struct timespec *tp);
> __attribute__((regparm(0))) long sys_clock_getres(clockid_t which_clock,
>    struct timespec *tp);
> __attribute__((regparm(0))) long sys_clock_nanosleep(clockid_t which_clock, int flags,
>    const struct timespec *rqtp,
>    struct timespec *rmtp);
>
> __attribute__((regparm(0))) long sys_nice(int increment);
> __attribute__((regparm(0))) long sys_sched_setscheduler(pid_t pid, int policy,
>     struct sched_param *param);
> __attribute__((regparm(0))) long sys_sched_setparam(pid_t pid,
>     struct sched_param *param);
> __attribute__((regparm(0))) long sys_sched_getscheduler(pid_t pid);
> __attribute__((regparm(0))) long sys_sched_getparam(pid_t pid,
>     struct sched_param *param);
> __attribute__((regparm(0))) long sys_sched_setaffinity(pid_t pid, unsigned int len,
>     unsigned long *user_mask_ptr);
> __attribute__((regparm(0))) long sys_sched_getaffinity(pid_t pid, unsigned int len,
>     unsigned long *user_mask_ptr);
> __attribute__((regparm(0))) long sys_sched_yield(void);
> __attribute__((regparm(0))) long sys_sched_get_priority_max(int policy);
> __attribute__((regparm(0))) long sys_sched_get_priority_min(int policy);
> __attribute__((regparm(0))) long sys_sched_rr_get_interval(pid_t pid,
>     struct timespec *interval);
> __attribute__((regparm(0))) long sys_setpriority(int which, int who, int niceval);
> __attribute__((regparm(0))) long sys_getpriority(int which, int who);
>
> __attribute__((regparm(0))) long sys_shutdown(int, int);
> __attribute__((regparm(0))) long sys_reboot(int magic1, int magic2, unsigned int cmd,
>    void *arg);
> __attribute__((regparm(0))) long sys_restart_syscall(void);
> __attribute__((regparm(0))) long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
>    struct kexec_segment *segments,
>    unsigned long flags);
>
> __attribute__((regparm(0))) long sys_exit(int error_code);
> __attribute__((regparm(0))) void sys_exit_group(int error_code);
> __attribute__((regparm(0))) long sys_wait4(pid_t pid, int *stat_addr,
>    int options, struct rusage *ru);
> __attribute__((regparm(0))) long sys_waitid(int which, pid_t pid,
>      struct siginfo *infop,
>      int options, struct rusage *ru);
> __attribute__((regparm(0))) long sys_waitpid(pid_t pid, int *stat_addr, int options);
> __attribute__((regparm(0))) long sys_set_tid_address(int *tidptr);
> __attribute__((regparm(0))) long sys_futex(u32 *uaddr, int op, u32 val,
>   struct timespec *utime, u32 *uaddr2,
>   u32 val3);
>
> __attribute__((regparm(0))) long sys_init_module(void *umod, unsigned long len,
>    const char *uargs);
> __attribute__((regparm(0))) long sys_delete_module(const char *name_user,
>    unsigned int flags);
>
> __attribute__((regparm(0))) long sys_rt_sigprocmask(int how, sigset_t *set,
>    sigset_t *oset, size_t sigsetsize);
> __attribute__((regparm(0))) long sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
> __attribute__((regparm(0))) long sys_rt_sigtimedwait(const sigset_t *uthese,
>    siginfo_t *uinfo,
>    const struct timespec *uts,
>    size_t sigsetsize);
> __attribute__((regparm(0))) long sys_kill(int pid, int sig);
> __attribute__((regparm(0))) long sys_tgkill(int tgid, int pid, int sig);
> __attribute__((regparm(0))) long sys_tkill(int pid, int sig);
> __attribute__((regparm(0))) long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
> __attribute__((regparm(0))) long sys_sgetmask(void);
> __attribute__((regparm(0))) long sys_ssetmask(int newmask);
> __attribute__((regparm(0))) unsigned long sys_signal(int sig, __sighandler_t handler);
> __attribute__((regparm(0))) long sys_pause(void);
>
> __attribute__((regparm(0))) long sys_sync(void);
> __attribute__((regparm(0))) long sys_fsync(unsigned int fd);
> __attribute__((regparm(0))) long sys_fdatasync(unsigned int fd);
> __attribute__((regparm(0))) long sys_bdflush(int func, long data);
> __attribute__((regparm(0))) long sys_mount(char *dev_name, char *dir_name,
>    char *type, unsigned long flags,
>    void *data);
> __attribute__((regparm(0))) long sys_umount(char *name, int flags);
> __attribute__((regparm(0))) long sys_oldumount(char *name);
> __attribute__((regparm(0))) long sys_truncate(const char *path,
>    unsigned long length);
> __attribute__((regparm(0))) long sys_ftruncate(unsigned int fd, unsigned long length);
> __attribute__((regparm(0))) long sys_stat(char *filename,
>   struct __old_kernel_stat *statbuf);
> __attribute__((regparm(0))) long sys_statfs(const char * path,
>    struct statfs *buf);
> __attribute__((regparm(0))) long sys_statfs64(const char *path, size_t sz,
>    struct statfs64 *buf);
> __attribute__((regparm(0))) long sys_fstatfs(unsigned int fd, struct statfs *buf);
> __attribute__((regparm(0))) long sys_fstatfs64(unsigned int fd, size_t sz,
>    struct statfs64 *buf);
> __attribute__((regparm(0))) long sys_lstat(char *filename,
>   struct __old_kernel_stat *statbuf);
> __attribute__((regparm(0))) long sys_fstat(unsigned int fd,
>   struct __old_kernel_stat *statbuf);
> __attribute__((regparm(0))) long sys_newstat(char *filename,
>    struct stat *statbuf);
> __attribute__((regparm(0))) long sys_newlstat(char *filename,
>    struct stat *statbuf);
> __attribute__((regparm(0))) long sys_newfstat(unsigned int fd, struct stat *statbuf);
> __attribute__((regparm(0))) long sys_ustat(unsigned dev, struct ustat *ubuf);
>
> __attribute__((regparm(0))) long sys_stat64(char *filename,
>    struct stat64 *statbuf);
> __attribute__((regparm(0))) long sys_fstat64(unsigned long fd, struct stat64 *statbuf);
> __attribute__((regparm(0))) long sys_lstat64(char *filename,
>    struct stat64 *statbuf);
> __attribute__((regparm(0))) long sys_truncate64(const char *path, loff_t length);
> __attribute__((regparm(0))) long sys_ftruncate64(unsigned int fd, loff_t length);
>
>
> __attribute__((regparm(0))) long sys_setxattr(char *path, char *name,
>    void *value, size_t size, int flags);
> __attribute__((regparm(0))) long sys_lsetxattr(char *path, char *name,
>    void *value, size_t size, int flags);
> __attribute__((regparm(0))) long sys_fsetxattr(int fd, char *name, void *value,
>    size_t size, int flags);
> __attribute__((regparm(0))) ssize_t sys_getxattr(char *path, char *name,
>    void *value, size_t size);
> __attribute__((regparm(0))) ssize_t sys_lgetxattr(char *path, char *name,
>    void *value, size_t size);
> __attribute__((regparm(0))) ssize_t sys_fgetxattr(int fd, char *name,
>    void *value, size_t size);
> __attribute__((regparm(0))) ssize_t sys_listxattr(char *path, char *list,
>    size_t size);
> __attribute__((regparm(0))) ssize_t sys_llistxattr(char *path, char *list,
>    size_t size);
> __attribute__((regparm(0))) ssize_t sys_flistxattr(int fd, char *list, size_t size);
> __attribute__((regparm(0))) long sys_removexattr(char *path, char *name);
> __attribute__((regparm(0))) long sys_lremovexattr(char *path, char *name);
> __attribute__((regparm(0))) long sys_fremovexattr(int fd, char *name);
>
> __attribute__((regparm(0))) unsigned long sys_brk(unsigned long brk);
> __attribute__((regparm(0))) long sys_mprotect(unsigned long start, size_t len,
>    unsigned long prot);
> __attribute__((regparm(0))) unsigned long sys_mremap(unsigned long addr,
>    unsigned long old_len, unsigned long new_len,
>    unsigned long flags, unsigned long new_addr);
> __attribute__((regparm(0))) long sys_remap_file_pages(unsigned long start, unsigned long size,
>   unsigned long prot, unsigned long pgoff,
>   unsigned long flags);
> __attribute__((regparm(0))) long sys_msync(unsigned long start, size_t len, int flags);
> __attribute__((regparm(0))) long sys_fadvise64(int fd, loff_t offset, size_t len, int advice);
> __attribute__((regparm(0))) long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice);
> __attribute__((regparm(0))) long sys_munmap(unsigned long addr, size_t len);
> __attribute__((regparm(0))) long sys_mlock(unsigned long start, size_t len);
> __attribute__((regparm(0))) long sys_munlock(unsigned long start, size_t len);
> __attribute__((regparm(0))) long sys_mlockall(int flags);
> __attribute__((regparm(0))) long sys_munlockall(void);
> __attribute__((regparm(0))) long sys_madvise(unsigned long start, size_t len, int behavior);
> __attribute__((regparm(0))) long sys_mincore(unsigned long start, size_t len,
>    unsigned char * vec);
>
> __attribute__((regparm(0))) long sys_pivot_root(const char *new_root,
>    const char *put_old);
> __attribute__((regparm(0))) long sys_chroot(const char *filename);
> __attribute__((regparm(0))) long sys_mknod(const char *filename, int mode,
>    unsigned dev);
> __attribute__((regparm(0))) long sys_link(const char *oldname,
>    const char *newname);
> __attribute__((regparm(0))) long sys_symlink(const char *old, const char *new);
> __attribute__((regparm(0))) long sys_unlink(const char *pathname);
> __attribute__((regparm(0))) long sys_rename(const char *oldname,
>    const char *newname);
> __attribute__((regparm(0))) long sys_chmod(const char *filename, mode_t mode);
> __attribute__((regparm(0))) long sys_fchmod(unsigned int fd, mode_t mode);
>
> __attribute__((regparm(0))) long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
>
> __attribute__((regparm(0))) long sys_fcntl64(unsigned int fd,
>    unsigned int cmd, unsigned long arg);
>
> __attribute__((regparm(0))) long sys_dup(unsigned int fildes);
> __attribute__((regparm(0))) long sys_dup2(unsigned int oldfd, unsigned int newfd);
> __attribute__((regparm(0))) long sys_ioperm(unsigned long from, unsigned long num, int on);
> __attribute__((regparm(0))) long sys_ioctl(unsigned int fd, unsigned int cmd,
>    unsigned long arg);
> __attribute__((regparm(0))) long sys_flock(unsigned int fd, unsigned int cmd);
> __attribute__((regparm(0))) long sys_io_setup(unsigned nr_reqs, aio_context_t *ctx);
> __attribute__((regparm(0))) long sys_io_destroy(aio_context_t ctx);
> __attribute__((regparm(0))) long sys_io_getevents(aio_context_t ctx_id,
>    long min_nr,
>    long nr,
>    struct io_event *events,
>    struct timespec *timeout);
> __attribute__((regparm(0))) long sys_io_submit(aio_context_t, long,
>    struct iocb * *);
> __attribute__((regparm(0))) long sys_io_cancel(aio_context_t ctx_id, struct iocb *iocb,
>         struct io_event *result);
> __attribute__((regparm(0))) ssize_t sys_sendfile(int out_fd, int in_fd,
>    off_t *offset, size_t count);
> __attribute__((regparm(0))) ssize_t sys_sendfile64(int out_fd, int in_fd,
>    loff_t *offset, size_t count);
> __attribute__((regparm(0))) long sys_readlink(const char *path,
>    char *buf, int bufsiz);
> __attribute__((regparm(0))) long sys_creat(const char *pathname, int mode);
> __attribute__((regparm(0))) long sys_open(const char *filename,
>    int flags, int mode);
> __attribute__((regparm(0))) long sys_close(unsigned int fd);
> __attribute__((regparm(0))) long sys_access(const char *filename, int mode);
> __attribute__((regparm(0))) long sys_vhangup(void);
> __attribute__((regparm(0))) long sys_chown(const char *filename,
>    uid_t user, gid_t group);
> __attribute__((regparm(0))) long sys_lchown(const char *filename,
>    uid_t user, gid_t group);
> __attribute__((regparm(0))) long sys_fchown(unsigned int fd, uid_t user, gid_t group);
>
> __attribute__((regparm(0))) long sys_chown16(const char *filename,
>    old_uid_t user, old_gid_t group);
> __attribute__((regparm(0))) long sys_lchown16(const char *filename,
>    old_uid_t user, old_gid_t group);
> __attribute__((regparm(0))) long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group);
> __attribute__((regparm(0))) long sys_setregid16(old_gid_t rgid, old_gid_t egid);
> __attribute__((regparm(0))) long sys_setgid16(old_gid_t gid);
> __attribute__((regparm(0))) long sys_setreuid16(old_uid_t ruid, old_uid_t euid);
> __attribute__((regparm(0))) long sys_setuid16(old_uid_t uid);
> __attribute__((regparm(0))) long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid);
> __attribute__((regparm(0))) long sys_getresuid16(old_uid_t *ruid,
>    old_uid_t *euid, old_uid_t *suid);
> __attribute__((regparm(0))) long sys_setresgid16(old_gid_t rgid, old_gid_t egid, old_gid_t sgid);
> __attribute__((regparm(0))) long sys_getresgid16(old_gid_t *rgid,
>    old_gid_t *egid, old_gid_t *sgid);
> __attribute__((regparm(0))) long sys_setfsuid16(old_uid_t uid);
> __attribute__((regparm(0))) long sys_setfsgid16(old_gid_t gid);
> __attribute__((regparm(0))) long sys_getgroups16(int gidsetsize, old_gid_t *grouplist);
> __attribute__((regparm(0))) long sys_setgroups16(int gidsetsize, old_gid_t *grouplist);
> __attribute__((regparm(0))) long sys_getuid16(void);
> __attribute__((regparm(0))) long sys_geteuid16(void);
> __attribute__((regparm(0))) long sys_getgid16(void);
> __attribute__((regparm(0))) long sys_getegid16(void);
>
>
> __attribute__((regparm(0))) long sys_utime(char *filename,
>    struct utimbuf *times);
> __attribute__((regparm(0))) long sys_utimes(char *filename,
>    struct timeval *utimes);
> __attribute__((regparm(0))) off_t sys_lseek(unsigned int fd, off_t offset,
>    unsigned int origin);
> __attribute__((regparm(0))) long sys_llseek(unsigned int fd, unsigned long offset_high,
>   unsigned long offset_low, loff_t *result,
>   unsigned int origin);
> __attribute__((regparm(0))) ssize_t sys_read(unsigned int fd, char *buf,
>    size_t count);
> __attribute__((regparm(0))) ssize_t sys_readahead(int fd, loff_t offset, size_t count);
> __attribute__((regparm(0))) ssize_t sys_readv(unsigned long fd,
>    const struct iovec *vec,
>    unsigned long vlen);
> __attribute__((regparm(0))) ssize_t sys_write(unsigned int fd, const char *buf,
>    size_t count);
> __attribute__((regparm(0))) ssize_t sys_writev(unsigned long fd,
>    const struct iovec *vec,
>    unsigned long vlen);
> __attribute__((regparm(0))) ssize_t sys_pread64(unsigned int fd, char *buf,
>    size_t count, loff_t pos);
> __attribute__((regparm(0))) ssize_t sys_pwrite64(unsigned int fd, const char *buf,
>    size_t count, loff_t pos);
> __attribute__((regparm(0))) long sys_getcwd(char *buf, unsigned long size);
> __attribute__((regparm(0))) long sys_mkdir(const char *pathname, int mode);
> __attribute__((regparm(0))) long sys_chdir(const char *filename);
> __attribute__((regparm(0))) long sys_fchdir(unsigned int fd);
> __attribute__((regparm(0))) long sys_rmdir(const char *pathname);
> __attribute__((regparm(0))) long sys_lookup_dcookie(u64 cookie64, char *buf, size_t len);
> __attribute__((regparm(0))) long sys_quotactl(unsigned int cmd, const char *special,
>    qid_t id, void *addr);
> __attribute__((regparm(0))) long sys_getdents(unsigned int fd,
>    struct linux_dirent *dirent,
>    unsigned int count);
> __attribute__((regparm(0))) long sys_getdents64(unsigned int fd,
>    struct linux_dirent64 *dirent,
>    unsigned int count);
>
> __attribute__((regparm(0))) long sys_setsockopt(int fd, int level, int optname,
>    char *optval, int optlen);
> __attribute__((regparm(0))) long sys_getsockopt(int fd, int level, int optname,
>    char *optval, int *optlen);
> __attribute__((regparm(0))) long sys_bind(int, struct sockaddr *, int);
> __attribute__((regparm(0))) long sys_connect(int, struct sockaddr *, int);
> __attribute__((regparm(0))) long sys_accept(int, struct sockaddr *, int *);
> __attribute__((regparm(0))) long sys_getsockname(int, struct sockaddr *, int *);
> __attribute__((regparm(0))) long sys_getpeername(int, struct sockaddr *, int *);
> __attribute__((regparm(0))) long sys_send(int, void *, size_t, unsigned);
> __attribute__((regparm(0))) long sys_sendto(int, void *, size_t, unsigned,
>    struct sockaddr *, int);
> __attribute__((regparm(0))) long sys_sendmsg(int fd, struct msghdr *msg, unsigned flags);
> __attribute__((regparm(0))) long sys_recv(int, void *, size_t, unsigned);
> __attribute__((regparm(0))) long sys_recvfrom(int, void *, size_t, unsigned,
>    struct sockaddr *, int *);
> __attribute__((regparm(0))) long sys_recvmsg(int fd, struct msghdr *msg, unsigned flags);
> __attribute__((regparm(0))) long sys_socket(int, int, int);
> __attribute__((regparm(0))) long sys_socketpair(int, int, int, int *);
> __attribute__((regparm(0))) long sys_socketcall(int call, unsigned long *args);
> __attribute__((regparm(0))) long sys_listen(int, int);
> __attribute__((regparm(0))) long sys_poll(struct pollfd *ufds, unsigned int nfds,
>    long timeout);
> __attribute__((regparm(0))) long sys_select(int n, fd_set *inp, fd_set *outp,
>   fd_set *exp, struct timeval *tvp);
> __attribute__((regparm(0))) long sys_epoll_create(int size);
> __attribute__((regparm(0))) long sys_epoll_ctl(int epfd, int op, int fd,
>    struct epoll_event *event);
> __attribute__((regparm(0))) long sys_epoll_wait(int epfd, struct epoll_event *events,
>    int maxevents, int timeout);
> __attribute__((regparm(0))) long sys_epoll_pwait(int epfd, struct epoll_event *events,
>    int maxevents, int timeout,
>    const sigset_t *sigmask,
>    size_t sigsetsize);
> __attribute__((regparm(0))) long sys_gethostname(char *name, int len);
> __attribute__((regparm(0))) long sys_sethostname(char *name, int len);
> __attribute__((regparm(0))) long sys_setdomainname(char *name, int len);
> __attribute__((regparm(0))) long sys_newuname(struct new_utsname *name);
>
> __attribute__((regparm(0))) long sys_getrlimit(unsigned int resource,
>    struct rlimit *rlim);
>
> __attribute__((regparm(0))) long sys_old_getrlimit(unsigned int resource, struct rlimit *rlim);
>
> __attribute__((regparm(0))) long sys_setrlimit(unsigned int resource,
>    struct rlimit *rlim);
> __attribute__((regparm(0))) long sys_getrusage(int who, struct rusage *ru);
> __attribute__((regparm(0))) long sys_umask(int mask);
>
> __attribute__((regparm(0))) long sys_msgget(key_t key, int msgflg);
> __attribute__((regparm(0))) long sys_msgsnd(int msqid, struct msgbuf *msgp,
>    size_t msgsz, int msgflg);
> __attribute__((regparm(0))) long sys_msgrcv(int msqid, struct msgbuf *msgp,
>    size_t msgsz, long msgtyp, int msgflg);
> __attribute__((regparm(0))) long sys_msgctl(int msqid, int cmd, struct msqid_ds *buf);
>
> __attribute__((regparm(0))) long sys_semget(key_t key, int nsems, int semflg);
> __attribute__((regparm(0))) long sys_semop(int semid, struct sembuf *sops,
>    unsigned nsops);
> __attribute__((regparm(0))) long sys_semctl(int semid, int semnum, int cmd, union semun arg);
> __attribute__((regparm(0))) long sys_semtimedop(int semid, struct sembuf *sops,
>    unsigned nsops,
>    const struct timespec *timeout);
> __attribute__((regparm(0))) long sys_shmat(int shmid, char *shmaddr, int shmflg);
> __attribute__((regparm(0))) long sys_shmget(key_t key, size_t size, int flag);
> __attribute__((regparm(0))) long sys_shmdt(char *shmaddr);
> __attribute__((regparm(0))) long sys_shmctl(int shmid, int cmd, struct shmid_ds *buf);
>
> __attribute__((regparm(0))) long sys_mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr);
> __attribute__((regparm(0))) long sys_mq_unlink(const char *name);
> __attribute__((regparm(0))) long sys_mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
> __attribute__((regparm(0))) ssize_t sys_mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout);
> __attribute__((regparm(0))) long sys_mq_notify(mqd_t mqdes, const struct sigevent *notification);
> __attribute__((regparm(0))) long sys_mq_getsetattr(mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat);
>
> __attribute__((regparm(0))) long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn);
> __attribute__((regparm(0))) long sys_pciconfig_read(unsigned long bus, unsigned long dfn,
>    unsigned long off, unsigned long len,
>    void *buf);
> __attribute__((regparm(0))) long sys_pciconfig_write(unsigned long bus, unsigned long dfn,
>    unsigned long off, unsigned long len,
>    void *buf);
>
> __attribute__((regparm(0))) long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
>   unsigned long arg4, unsigned long arg5);
> __attribute__((regparm(0))) long sys_swapon(const char *specialfile, int swap_flags);
> __attribute__((regparm(0))) long sys_swapoff(const char *specialfile);
> __attribute__((regparm(0))) long sys_sysctl(struct __sysctl_args *args);
> __attribute__((regparm(0))) long sys_sysinfo(struct sysinfo *info);
> __attribute__((regparm(0))) long sys_sysfs(int option,
>    unsigned long arg1, unsigned long arg2);
> __attribute__((regparm(0))) long sys_nfsservctl(int cmd,
>    struct nfsctl_arg *arg,
>    void *res);
> __attribute__((regparm(0))) long sys_syslog(int type, char *buf, int len);
> __attribute__((regparm(0))) long sys_uselib(const char *library);
> __attribute__((regparm(0))) long sys_ni_syscall(void);
> __attribute__((regparm(0))) long sys_ptrace(long request, long pid, long addr, long data);
>
> __attribute__((regparm(0))) long sys_add_key(const char *_type,
>       const char *_description,
>       const void *_payload,
>       size_t plen,
>       key_serial_t destringid);
>
> __attribute__((regparm(0))) long sys_request_key(const char *_type,
>    const char *_description,
>    const char *_callout_info,
>    key_serial_t destringid);
>
> __attribute__((regparm(0))) long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3,
>      unsigned long arg4, unsigned long arg5);
>
> __attribute__((regparm(0))) long sys_ioprio_set(int which, int who, int ioprio);
> __attribute__((regparm(0))) long sys_ioprio_get(int which, int who);
> __attribute__((regparm(0))) long sys_set_mempolicy(int mode, unsigned long *nmask,
>    unsigned long maxnode);
> __attribute__((regparm(0))) long sys_migrate_pages(pid_t pid, unsigned long maxnode,
>    const unsigned long *from,
>    const unsigned long *to);
> __attribute__((regparm(0))) long sys_move_pages(pid_t pid, unsigned long nr_pages,
>    const void * *pages,
>    const int *nodes,
>    int *status,
>    int flags);
> __attribute__((regparm(0))) long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
>    __u32 *pages,
>    const int *nodes,
>    int *status,
>    int flags);
> __attribute__((regparm(0))) long sys_mbind(unsigned long start, unsigned long len,
>    unsigned long mode,
>    unsigned long *nmask,
>    unsigned long maxnode,
>    unsigned flags);
> __attribute__((regparm(0))) long sys_get_mempolicy(int *policy,
>    unsigned long *nmask,
>    unsigned long maxnode,
>    unsigned long addr, unsigned long flags);
>
> __attribute__((regparm(0))) long sys_inotify_init(void);
> __attribute__((regparm(0))) long sys_inotify_add_watch(int fd, const char *path,
>     u32 mask);
> __attribute__((regparm(0))) long sys_inotify_rm_watch(int fd, u32 wd);
>
> __attribute__((regparm(0))) long sys_spu_run(int fd, __u32 *unpc,
>     __u32 *ustatus);
> __attribute__((regparm(0))) long sys_spu_create(const char *name,
>  unsigned int flags, mode_t mode, int fd);
>
> __attribute__((regparm(0))) long sys_mknodat(int dfd, const char * filename, int mode,
>       unsigned dev);
> __attribute__((regparm(0))) long sys_mkdirat(int dfd, const char * pathname, int mode);
> __attribute__((regparm(0))) long sys_unlinkat(int dfd, const char * pathname, int flag);
> __attribute__((regparm(0))) long sys_symlinkat(const char * oldname,
>         int newdfd, const char * newname);
> __attribute__((regparm(0))) long sys_linkat(int olddfd, const char *oldname,
>      int newdfd, const char *newname, int flags);
> __attribute__((regparm(0))) long sys_renameat(int olddfd, const char * oldname,
>        int newdfd, const char * newname);
> __attribute__((regparm(0))) long sys_futimesat(int dfd, char *filename,
>         struct timeval *utimes);
> __attribute__((regparm(0))) long sys_faccessat(int dfd, const char *filename, int mode);
> __attribute__((regparm(0))) long sys_fchmodat(int dfd, const char * filename,
>        mode_t mode);
> __attribute__((regparm(0))) long sys_fchownat(int dfd, const char *filename, uid_t user,
>        gid_t group, int flag);
> __attribute__((regparm(0))) long sys_openat(int dfd, const char *filename, int flags,
>      int mode);
> __attribute__((regparm(0))) long sys_newfstatat(int dfd, char *filename,
>          struct stat *statbuf, int flag);
> __attribute__((regparm(0))) long sys_fstatat64(int dfd, char *filename,
>          struct stat64 *statbuf, int flag);
> __attribute__((regparm(0))) long sys_readlinkat(int dfd, const char *path, char *buf,
>          int bufsiz);
> __attribute__((regparm(0))) long sys_utimensat(int dfd, char *filename,
>    struct timespec *utimes, int flags);
> __attribute__((regparm(0))) long compat_sys_futimesat(unsigned int dfd, char *filename,
>         struct compat_timeval *t);
> __attribute__((regparm(0))) long compat_sys_newfstatat(unsigned int dfd, char * filename,
>          struct compat_stat *statbuf,
>          int flag);
> __attribute__((regparm(0))) long compat_sys_openat(unsigned int dfd, const char *filename,
>       int flags, int mode);
> __attribute__((regparm(0))) long sys_unshare(unsigned long unshare_flags);
>
> __attribute__((regparm(0))) long sys_splice(int fd_in, loff_t *off_in,
>      int fd_out, loff_t *off_out,
>      size_t len, unsigned int flags);
>
> __attribute__((regparm(0))) long sys_vmsplice(int fd, const struct iovec *iov,
>        unsigned long nr_segs, unsigned int flags);
>
> __attribute__((regparm(0))) long sys_tee(int fdin, int fdout, size_t len, unsigned int flags);
>
> __attribute__((regparm(0))) long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
>     unsigned int flags);
> __attribute__((regparm(0))) long sys_sync_file_range2(int fd, unsigned int flags,
>         loff_t offset, loff_t nbytes);
> __attribute__((regparm(0))) long sys_get_robust_list(int pid,
>        struct robust_list_head * *head_ptr,
>        size_t *len_ptr);
> __attribute__((regparm(0))) long sys_set_robust_list(struct robust_list_head *head,
>        size_t len);
> __attribute__((regparm(0))) long sys_getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *cache);
> __attribute__((regparm(0))) long sys_signalfd(int ufd, sigset_t *user_mask, size_t sizemask);
> __attribute__((regparm(0))) long sys_timerfd(int ufd, int clockid, int flags,
>       const struct itimerspec *utmr);
> __attribute__((regparm(0))) long sys_eventfd(unsigned int count);
> __attribute__((regparm(0))) long sys_fallocate(int fd, int mode, loff_t offset, loff_t len);
>
>int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
># 41 "kernel/hrtimer.c" 2
># 1 "include/linux/kallsyms.h" 1
># 17 "include/linux/kallsyms.h"
>unsigned long kallsyms_lookup_name(const char *name);
>
>extern int kallsyms_lookup_size_offset(unsigned long addr,
>      unsigned long *symbolsize,
>      unsigned long *offset);
>
>
>const char *kallsyms_lookup(unsigned long addr,
>       unsigned long *symbolsize,
>       unsigned long *offset,
>       char **modname, char *namebuf);
>
>
>extern int sprint_symbol(char *buffer, unsigned long address);
>
>
>extern void __print_symbol(const char *fmt, unsigned long address);
>
>int lookup_symbol_name(unsigned long addr, char *symname);
>int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
># 81 "include/linux/kallsyms.h"
>static void __check_printsym_format(const char *fmt, ...)
>__attribute__((format(printf,1,2)));
>static inline __attribute__((always_inline)) void __check_printsym_format(const char *fmt, ...)
>{
>}
># 97 "include/linux/kallsyms.h"
>static inline __attribute__((always_inline)) void print_symbol(const char *fmt, unsigned long addr)
>{
> __check_printsym_format(fmt, "");
> __print_symbol(fmt, (unsigned long)
>         __builtin_extract_return_addr((void *)addr));
>}
># 42 "kernel/hrtimer.c" 2
># 1 "include/linux/interrupt.h" 1
># 11 "include/linux/interrupt.h"
># 1 "include/linux/hardirq.h" 1
>
>
>
>
># 1 "include/linux/smp_lock.h" 1
># 9 "include/linux/smp_lock.h"
>extern int __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) __reacquire_kernel_lock(void);
>extern void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) __release_kernel_lock(void);
># 32 "include/linux/smp_lock.h"
>static inline __attribute__((always_inline)) int reacquire_kernel_lock(struct task_struct *task)
>{
> if (__builtin_expect(!!(task->lock_depth >= 0), 0))
>  __reacquire_kernel_lock();
> return 0;
>}
>
>extern void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) lock_kernel(void) ;
>extern void __attribute__((regparm(3))) __attribute__((section(".spinlock.text"))) unlock_kernel(void) ;
># 6 "include/linux/hardirq.h" 2
>
># 1 "include/asm/hardirq.h" 1
>
># 1 "include/asm/hardirq_32.h" 1
>
>
>
>
>
>
>typedef struct {
> unsigned int __softirq_pending;
> unsigned long idle_timestamp;
> unsigned int __nmi_count;
> unsigned int apic_timer_irqs;
> unsigned int irq0_irqs;
> unsigned int irq_resched_count;
> unsigned int irq_call_count;
> unsigned int irq_tlb_count;
> unsigned int irq_thermal_count;
> unsigned int irq_spurious_count;
>} __attribute__((__aligned__((1 << (7))))) irq_cpustat_t;
>
>extern __typeof__(irq_cpustat_t) per_cpu__irq_stat;
>
>
>
>
>void ack_bad_irq(unsigned int irq);
># 1 "include/linux/irq_cpustat.h" 1
># 27 "include/asm/hardirq_32.h" 2
># 3 "include/asm/hardirq.h" 2
># 8 "include/linux/hardirq.h" 2
># 1 "include/asm/system.h" 1
># 9 "include/linux/hardirq.h" 2
># 103 "include/linux/hardirq.h"
>extern void synchronize_irq(unsigned int irq);
>
>
>
>
>struct task_struct;
>
>
>static inline __attribute__((always_inline)) void account_system_vtime(struct task_struct *tsk)
>{
>}
># 132 "include/linux/hardirq.h"
>extern void irq_enter(void);
># 147 "include/linux/hardirq.h"
>extern void irq_exit(void);
># 12 "include/linux/interrupt.h" 2
>
>
># 1 "include/asm/atomic.h" 1
># 15 "include/linux/interrupt.h" 2
>
># 1 "include/asm/system.h" 1
># 17 "include/linux/interrupt.h" 2
># 58 "include/linux/interrupt.h"
>typedef irqreturn_t (*irq_handler_t)(int, void *);
>
>struct irqaction {
> irq_handler_t handler;
> unsigned long flags;
> cpumask_t mask;
> const char *name;
> void *dev_id;
> struct irqaction *next;
> int irq;
> struct proc_dir_entry *dir;
>};
>
>extern irqreturn_t no_action(int cpl, void *dev_id);
>extern int __attribute__((warn_unused_result)) request_irq(unsigned int, irq_handler_t handler,
>         unsigned long, const char *, void *);
>extern void free_irq(unsigned int, void *);
>
>struct device;
>
>extern int __attribute__((warn_unused_result)) devm_request_irq(struct device *dev, unsigned int irq,
>       irq_handler_t handler, unsigned long irqflags,
>       const char *devname, void *dev_id);
>extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
># 101 "include/linux/interrupt.h"
>extern void disable_irq_nosync(unsigned int irq);
>extern void disable_irq(unsigned int irq);
>extern void enable_irq(unsigned int irq);
># 117 "include/linux/interrupt.h"
>static inline __attribute__((always_inline)) void disable_irq_nosync_lockdep(unsigned int irq)
>{
> disable_irq_nosync(irq);
>
>
>
>}
>
>static inline __attribute__((always_inline)) void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
>{
> disable_irq_nosync(irq);
>
>
>
>}
>
>static inline __attribute__((always_inline)) void disable_irq_lockdep(unsigned int irq)
>{
> disable_irq(irq);
>
>
>
>}
>
>static inline __attribute__((always_inline)) void enable_irq_lockdep(unsigned int irq)
>{
>
>
>
> enable_irq(irq);
>}
>
>static inline __attribute__((always_inline)) void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
>{
>
>
>
> enable_irq(irq);
>}
>
>
>extern int set_irq_wake(unsigned int irq, unsigned int on);
>
>static inline __attribute__((always_inline)) int enable_irq_wake(unsigned int irq)
>{
> return set_irq_wake(irq, 1);
>}
>
>static inline __attribute__((always_inline)) int disable_irq_wake(unsigned int irq)
>{
> return set_irq_wake(irq, 0);
>}
># 247 "include/linux/interrupt.h"
>enum
>{
> HI_SOFTIRQ=0,
> TIMER_SOFTIRQ,
> NET_TX_SOFTIRQ,
> NET_RX_SOFTIRQ,
> BLOCK_SOFTIRQ,
> TASKLET_SOFTIRQ,
> SCHED_SOFTIRQ,
>
> HRTIMER_SOFTIRQ,
>
>};
>
>
>
>
>
>struct softirq_action
>{
> void (*action)(struct softirq_action *);
> void *data;
>};
>
> __attribute__((regparm(0))) void do_softirq(void);
>extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data);
>extern void softirq_init(void);
>
>extern void raise_softirq_irqoff(unsigned int nr) __attribute__((regparm(3)));
>extern void raise_softirq(unsigned int nr) __attribute__((regparm(3)));
># 299 "include/linux/interrupt.h"
>struct tasklet_struct
>{
> struct tasklet_struct *next;
> unsigned long state;
> atomic_t count;
> void (*func)(unsigned long);
> unsigned long data;
>};
># 315 "include/linux/interrupt.h"
>enum
>{
> TASKLET_STATE_SCHED,
> TASKLET_STATE_RUN
>};
>
>
>static inline __attribute__((always_inline)) int tasklet_trylock(struct tasklet_struct *t)
>{
> return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
>}
>
>static inline __attribute__((always_inline)) void tasklet_unlock(struct tasklet_struct *t)
>{
> __asm__ __volatile__("": : :"memory");
> clear_bit(TASKLET_STATE_RUN, &(t)->state);
>}
>
>static inline __attribute__((always_inline)) void tasklet_unlock_wait(struct tasklet_struct *t)
>{
> while ((__builtin_constant_p(TASKLET_STATE_RUN) ? constant_test_bit((TASKLET_STATE_RUN),(&(t)->state)) : variable_test_bit((TASKLET_STATE_RUN),(&(t)->state)))) { __asm__ __volatile__("": : :"memory"); }
>}
>
>
>
>
>
>
>extern void __tasklet_schedule(struct tasklet_struct *t) __attribute__((regparm(3)));
>
>static inline __attribute__((always_inline)) void tasklet_schedule(struct tasklet_struct *t)
>{
> if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
>  __tasklet_schedule(t);
>}
>
>extern void __tasklet_hi_schedule(struct tasklet_struct *t) __attribute__((regparm(3)));
>
>static inline __attribute__((always_inline)) void tasklet_hi_schedule(struct tasklet_struct *t)
>{
> if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
>  __tasklet_hi_schedule(t);
>}
>
>
>static inline __attribute__((always_inline)) void tasklet_disable_nosync(struct tasklet_struct *t)
>{
> atomic_inc(&t->count);
> __asm__ __volatile__("": : :"memory");
>}
>
>static inline __attribute__((always_inline)) void tasklet_disable(struct tasklet_struct *t)
>{
> tasklet_disable_nosync(t);
> tasklet_unlock_wait(t);
> asm volatile ("661:\n\t" "lock; addl $0,0(%%esp)" "\n662:\n" ".section .altinstructions,\"a\"\n" "  .align 4\n" "  .long 661b\n" "  .long 663f\n" "  .byte %c0\n" "  .byte 662b-661b\n" "  .byte 664f-663f\n" ".previous\n" ".section .altinstr_replacement,\"ax\"\n" "663:\n\t" "mfence" "\n664:\n" ".previous" :: "i" ((0*32+26)) : "memory");
>}
>
>static inline __attribute__((always_inline)) void tasklet_enable(struct tasklet_struct *t)
>{
> __asm__ __volatile__("": : :"memory");
> atomic_dec(&t->count);
>}
>
>static inline __attribute__((always_inline)) void tasklet_hi_enable(struct tasklet_struct *t)
>{
> __asm__ __volatile__("": : :"memory");
> atomic_dec(&t->count);
>}
>
>extern void tasklet_kill(struct tasklet_struct *t);
>extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
>extern void tasklet_init(struct tasklet_struct *t,
>    void (*func)(unsigned long), unsigned long data);
># 432 "include/linux/interrupt.h"
>extern unsigned long probe_irq_on(void);
>extern int probe_irq_off(unsigned long);
>extern unsigned int probe_irq_mask(unsigned long);
>
>
>
>
>extern void init_irq_proc(void);
># 43 "kernel/hrtimer.c" 2
># 1 "include/linux/tick.h" 1
># 9 "include/linux/tick.h"
># 1 "include/linux/clockchips.h" 1
># 13 "include/linux/clockchips.h"
># 1 "include/linux/clocksource.h" 1
># 18 "include/linux/clocksource.h"
># 1 "include/asm/io.h" 1
>
># 1 "include/asm/io_32.h" 1
># 47 "include/asm/io_32.h"
># 1 "include/asm-generic/iomap.h" 1
># 28 "include/asm-generic/iomap.h"
>extern unsigned int __attribute__((regparm(3))) ioread8(void *);
>extern unsigned int __attribute__((regparm(3))) ioread16(void *);
>extern unsigned int __attribute__((regparm(3))) ioread16be(void *);
>extern unsigned int __attribute__((regparm(3))) ioread32(void *);
>extern unsigned int __attribute__((regparm(3))) ioread32be(void *);
>
>extern void __attribute__((regparm(3))) iowrite8(u8, void *);
>extern void __attribute__((regparm(3))) iowrite16(u16, void *);
>extern void __attribute__((regparm(3))) iowrite16be(u16, void *);
>extern void __attribute__((regparm(3))) iowrite32(u32, void *);
>extern void __attribute__((regparm(3))) iowrite32be(u32, void *);
># 51 "include/asm-generic/iomap.h"
>extern void __attribute__((regparm(3))) ioread8_rep(void *port, void *buf, unsigned long count);
>extern void __attribute__((regparm(3))) ioread16_rep(void *port, void *buf, unsigned long count);
>extern void __attribute__((regparm(3))) ioread32_rep(void *port, void *buf, unsigned long count);
>
>extern void __attribute__((regparm(3))) iowrite8_rep(void *port, const void *buf, unsigned long count);
>extern void __attribute__((regparm(3))) iowrite16_rep(void *port, const void *buf, unsigned long count);
>extern void __attribute__((regparm(3))) iowrite32_rep(void *port, const void *buf, unsigned long count);
>
>
>extern void *ioport_map(unsigned long port, unsigned int nr);
>extern void ioport_unmap(void *);
>
>
>struct pci_dev;
>extern void *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
>extern void pci_iounmap(struct pci_dev *dev, void *);
># 48 "include/asm/io_32.h" 2
>
># 1 "include/linux/vmalloc.h" 1
>
>
>
>
># 1 "include/asm/page.h" 1
># 6 "include/linux/vmalloc.h" 2
>
>struct vm_area_struct;
># 25 "include/linux/vmalloc.h"
>struct vm_struct {
>
> struct vm_struct *next;
> void *addr;
> unsigned long size;
> unsigned long flags;
> struct page **pages;
> unsigned int nr_pages;
> unsigned long phys_addr;
>};
>
>
>
>
>extern void *vmalloc(unsigned long size);
>extern void *vmalloc_user(unsigned long size);
>extern void *vmalloc_node(unsigned long size, int node);
>extern void *vmalloc_exec(unsigned long size);
>extern void *vmalloc_32(unsigned long size);
>extern void *vmalloc_32_user(unsigned long size);
>extern void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot);
>extern void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask,
>    pgprot_t prot);
>extern void vfree(void *addr);
>
>extern void *vmap(struct page **pages, unsigned int count,
>   unsigned long flags, pgprot_t prot);
>extern void vunmap(void *addr);
>
>extern int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
>       unsigned long pgoff);
>void vmalloc_sync_all(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) size_t get_vm_area_size(const struct vm_struct *area)
>{
>
> return area->size - (1UL << 12);
>}
>
>extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
>extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
>     unsigned long start, unsigned long end);
>extern struct vm_struct *get_vm_area_node(unsigned long size,
>       unsigned long flags, int node,
>       gfp_t gfp_mask);
>extern struct vm_struct *remove_vm_area(void *addr);
>
>extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
>   struct page ***pages);
>extern void unmap_kernel_range(unsigned long addr, unsigned long size);
>
>
>extern struct vm_struct *alloc_vm_area(size_t size);
>extern void free_vm_area(struct vm_struct *area);
>
>
>
>
>extern rwlock_t vmlist_lock;
>extern struct vm_struct *vmlist;
># 50 "include/asm/io_32.h" 2
># 75 "include/asm/io_32.h"
>static inline __attribute__((always_inline)) unsigned long virt_to_phys(volatile void * address)
>{
> return ((unsigned long)(address)-((unsigned long)((unsigned long)0xC0000000)));
>}
># 93 "include/asm/io_32.h"
>static inline __attribute__((always_inline)) void * phys_to_virt(unsigned long address)
>{
> return ((void *)((unsigned long)(address)+((unsigned long)((unsigned long)0xC0000000))));
>}
>
>
>
>
>
>
>extern void * __ioremap(unsigned long offset, unsigned long size, unsigned long flags);
># 120 "include/asm/io_32.h"
>static inline __attribute__((always_inline)) void * ioremap(unsigned long offset, unsigned long size)
>{
> return __ioremap(offset, size, 0);
>}
>
>extern void * ioremap_nocache(unsigned long offset, unsigned long size);
>extern void iounmap(volatile void *addr);
>
>
>
>
>
>
>extern void *bt_ioremap(unsigned long offset, unsigned long size);
>extern void bt_iounmap(void *addr, unsigned long size);
>extern void *fix_ioremap(unsigned idx, unsigned long phys);
># 165 "include/asm/io_32.h"
>static inline __attribute__((always_inline)) unsigned char readb(const volatile void *addr)
>{
> return *(volatile unsigned char *) addr;
>}
>static inline __attribute__((always_inline)) unsigned short readw(const volatile void *addr)
>{
> return *(volatile unsigned short *) addr;
>}
>static inline __attribute__((always_inline)) unsigned int readl(const volatile void *addr)
>{
> return *(volatile unsigned int *) addr;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void writeb(unsigned char b, volatile void *addr)
>{
> *(volatile unsigned char *) addr = b;
>}
>static inline __attribute__((always_inline)) void writew(unsigned short b, volatile void *addr)
>{
> *(volatile unsigned short *) addr = b;
>}
>static inline __attribute__((always_inline)) void writel(unsigned int b, volatile void *addr)
>{
> *(volatile unsigned int *) addr = b;
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void
>memset_io(volatile void *addr, unsigned char val, int count)
>{
> (__builtin_constant_p(val) ? (__builtin_constant_p((count)) ? __constant_c_and_count_memset((((void *)addr)),((0x01010101UL*(unsigned char)(val))),((count))) : __constant_c_memset((((void *)addr)),((0x01010101UL*(unsigned char)(val))),((count)))) : (__builtin_constant_p((count)) ? __memset_generic(((((void *)addr))),(((val))),(((count)))) : __memset_generic((((void *)addr)),((val)),((count)))));
>}
>
>static inline __attribute__((always_inline)) void
>memcpy_fromio(void *dst, const volatile void *src, int count)
>{
> __memcpy(dst, (const void *)src, count);
>}
>
>static inline __attribute__((always_inline)) void
>memcpy_toio(volatile void *dst, const void *src, int count)
>{
> __memcpy((void *)dst, src, count);
>}
># 253 "include/asm/io_32.h"
>static inline __attribute__((always_inline)) void native_io_delay(void)
>{
> asm volatile("outb %%al,$0x80" : : : "memory");
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) void slow_down_io(void) {
> native_io_delay();
>
>
>
>
>
>}
># 341 "include/asm/io_32.h"
>static inline __attribute__((always_inline)) void outb_local(unsigned char value, int port) { __asm__ __volatile__("out" "b" " %" "b" "0, %w1" : : "a"(value), "Nd"(port)); } static inline __attribute__((always_inline)) unsigned char inb_local(int port) { unsigned char value; __asm__ __volatile__("in" "b" " %w1, %" "b" "0" : "=a"(value) : "Nd"(port)); return value; } static inline __attribute__((always_inline)) void outb_local_p(unsigned char value, int port) { outb_local(value, port); slow_down_io(); } static inline __attribute__((always_inline)) unsigned char inb_local_p(int port) { unsigned char value = inb_local(port); slow_down_io(); return value; } static inline __attribute__((always_inline)) void outb(unsigned char value, int port) { outb_local(value, port); } static inline __attribute__((always_inline)) unsigned char inb(int port) { return inb_local(port); } static inline __attribute__((always_inline)) void outb_p(unsigned char value, int port) { outb(value, port); slow_down_io(); } static inline __attribute__((always_inline)) unsigned char inb_p(int port) { unsigned char value = inb(port); slow_down_io(); return value; } static inline __attribute__((always_inline)) void outsb(int port, const void *addr, unsigned long count) { __asm__ __volatile__("rep; outs" "b" : "+S"(addr), "+c"(count) : "d"(port)); } static inline __attribute__((always_inline)) void insb(int port, void *addr, unsigned long count) { __asm__ __volatile__("rep; ins" "b" : "+D"(addr), "+c"(count) : "d"(port)); }
>static inline __attribute__((always_inline)) void outw_local(unsigned short value, int port) { __asm__ __volatile__("out" "w" " %" "w" "0, %w1" : : "a"(value), "Nd"(port)); } static inline __attribute__((always_inline)) unsigned short inw_local(int port) { unsigned short value; __asm__ __volatile__("in" "w" " %w1, %" "w" "0" : "=a"(value) : "Nd"(port)); return value; } static inline __attribute__((always_inline)) void outw_local_p(unsigned short value, int port) { outw_local(value, port); slow_down_io(); } static inline __attribute__((always_inline)) unsigned short inw_local_p(int port) { unsigned short value = inw_local(port); slow_down_io(); return value; } static inline __attribute__((always_inline)) void outw(unsigned short value, int port) { outw_local(value, port); } static inline __attribute__((always_inline)) unsigned short inw(int port) { return inw_local(port); } static inline __attribute__((always_inline)) void outw_p(unsigned short value, int port) { outw(value, port); slow_down_io(); } static inline __attribute__((always_inline)) unsigned short inw_p(int port) { unsigned short value = inw(port); slow_down_io(); return value; } static inline __attribute__((always_inline)) void outsw(int port, const void *addr, unsigned long count) { __asm__ __volatile__("rep; outs" "w" : "+S"(addr), "+c"(count) : "d"(port)); } static inline __attribute__((always_inline)) void insw(int port, void *addr, unsigned long count) { __asm__ __volatile__("rep; ins" "w" : "+D"(addr), "+c"(count) : "d"(port)); }
>static inline __attribute__((always_inline)) void outl_local(unsigned int value, int port) { __asm__ __volatile__("out" "l" " %" "" "0, %w1" : : "a"(value), "Nd"(port)); } static inline __attribute__((always_inline)) unsigned int inl_local(int port) { unsigned int value; __asm__ __volatile__("in" "l" " %w1, %" "" "0" : "=a"(value) : "Nd"(port)); return value; } static inline __attribute__((always_inline)) void outl_local_p(unsigned int value, int port) { outl_local(value, port); slow_down_io(); } static inline __attribute__((always_inline)) unsigned int inl_local_p(int port) { unsigned int value = inl_local(port); slow_down_io(); return value; } static inline __attribute__((always_inline)) void outl(unsigned int value, int port) { outl_local(value, port); } static inline __attribute__((always_inline)) unsigned int inl(int port) { return inl_local(port); } static inline __attribute__((always_inline)) void outl_p(unsigned int value, int port) { outl(value, port); slow_down_io(); } static inline __attribute__((always_inline)) unsigned int inl_p(int port) { unsigned int value = inl(port); slow_down_io(); return value; } static inline __attribute__((always_inline)) void outsl(int port, const void *addr, unsigned long count) { __asm__ __volatile__("rep; outs" "l" : "+S"(addr), "+c"(count) : "d"(port)); } static inline __attribute__((always_inline)) void insl(int port, void *addr, unsigned long count) { __asm__ __volatile__("rep; ins" "l" : "+D"(addr), "+c"(count) : "d"(port)); }
># 3 "include/asm/io.h" 2
># 19 "include/linux/clocksource.h" 2
>
>
>typedef u64 cycle_t;
>struct clocksource;
># 56 "include/linux/clocksource.h"
>struct clocksource {
>
>
>
> char *name;
> struct list_head list;
> int rating;
> cycle_t (*read)(void);
> cycle_t mask;
> u32 mult;
> u32 shift;
> unsigned long flags;
> cycle_t (*vread)(void);
> void (*resume)(void);
># 78 "include/linux/clocksource.h"
> cycle_t cycle_interval;
> u64 xtime_interval;
>
>
>
>
>
> cycle_t cycle_last __attribute__((__aligned__((1 << (7)))));
> u64 xtime_nsec;
> s64 error;
>
>
>
> struct list_head wd_list;
> cycle_t wd_last;
>
>};
># 116 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) u32 clocksource_khz2mult(u32 khz, u32 shift_constant)
>{
>
>
>
>
>
>
>
> u64 tmp = ((u64)1000000) << shift_constant;
>
> tmp += khz/2;
> ({ unsigned long __upper, __low, __high, __mod, __base; __base = (khz); asm("":"=a" (__low), "=d" (__high):"A" (tmp)); __upper = __high; if (__high) { __upper = __high % (__base); __high = __high / (__base); } asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); asm("":"=A" (tmp):"a" (__low),"d" (__high)); __mod; });
>
> return (u32)tmp;
>}
># 142 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) u32 clocksource_hz2mult(u32 hz, u32 shift_constant)
>{
>
>
>
>
>
>
>
> u64 tmp = ((u64)1000000000) << shift_constant;
>
> tmp += hz/2;
> ({ unsigned long __upper, __low, __high, __mod, __base; __base = (hz); asm("":"=a" (__low), "=d" (__high):"A" (tmp)); __upper = __high; if (__high) { __upper = __high % (__base); __high = __high / (__base); } asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); asm("":"=A" (tmp):"a" (__low),"d" (__high)); __mod; });
>
> return (u32)tmp;
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) cycle_t clocksource_read(struct clocksource *cs)
>{
> return cs->read();
>}
># 179 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) s64 cyc2ns(struct clocksource *cs, cycle_t cycles)
>{
> u64 ret = (u64)cycles;
> ret = (ret * cs->mult) >> cs->shift;
> return ret;
>}
># 197 "include/linux/clocksource.h"
>static inline __attribute__((always_inline)) void clocksource_calculate_interval(struct clocksource *c,
>          unsigned long length_nsec)
>{
> u64 tmp;
>
>
> tmp = length_nsec;
> tmp <<= c->shift;
> tmp += c->mult/2;
> ({ unsigned long __upper, __low, __high, __mod, __base; __base = (c->mult); asm("":"=a" (__low), "=d" (__high):"A" (tmp)); __upper = __high; if (__high) { __upper = __high % (__base); __high = __high / (__base); } asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); asm("":"=A" (tmp):"a" (__low),"d" (__high)); __mod; });
>
> c->cycle_interval = (cycle_t)tmp;
> if (c->cycle_interval == 0)
>  c->cycle_interval = 1;
>
> c->xtime_interval = (u64)c->cycle_interval * c->mult;
>}
>
>
>
>extern int clocksource_register(struct clocksource*);
>extern struct clocksource* clocksource_get_next(void);
>extern void clocksource_change_rating(struct clocksource *cs, int rating);
>extern void clocksource_resume(void);
>
>
>
>
>
>static inline __attribute__((always_inline)) void update_vsyscall(struct timespec *ts, struct clocksource *c)
>{
>}
>
>static inline __attribute__((always_inline)) void update_vsyscall_tz(void)
>{
>}
># 14 "include/linux/clockchips.h" 2
>
>
>
>
>struct clock_event_device;
>
>
>enum clock_event_mode {
> CLOCK_EVT_MODE_UNUSED = 0,
> CLOCK_EVT_MODE_SHUTDOWN,
> CLOCK_EVT_MODE_PERIODIC,
> CLOCK_EVT_MODE_ONESHOT,
> CLOCK_EVT_MODE_RESUME,
>};
>
>
>enum clock_event_nofitiers {
> CLOCK_EVT_NOTIFY_ADD,
> CLOCK_EVT_NOTIFY_BROADCAST_ON,
> CLOCK_EVT_NOTIFY_BROADCAST_OFF,
> CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
> CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
> CLOCK_EVT_NOTIFY_BROADCAST_EXIT,
> CLOCK_EVT_NOTIFY_SUSPEND,
> CLOCK_EVT_NOTIFY_RESUME,
> CLOCK_EVT_NOTIFY_CPU_DEAD,
>};
># 76 "include/linux/clockchips.h"
>struct clock_event_device {
> const char *name;
> unsigned int features;
> unsigned long max_delta_ns;
> unsigned long min_delta_ns;
> unsigned long mult;
> int shift;
> int rating;
> int irq;
> cpumask_t cpumask;
> int (*set_next_event)(unsigned long evt,
>        struct clock_event_device *);
> void (*set_mode)(enum clock_event_mode mode,
>         struct clock_event_device *);
> void (*event_handler)(struct clock_event_device *);
> void (*broadcast)(cpumask_t mask);
> struct list_head list;
> enum clock_event_mode mode;
> ktime_t next_event;
>};
># 108 "include/linux/clockchips.h"
>static inline __attribute__((always_inline)) unsigned long div_sc(unsigned long ticks, unsigned long nsec,
>       int shift)
>{
> uint64_t tmp = ((uint64_t)ticks) << shift;
>
> ({ unsigned long __upper, __low, __high, __mod, __base; __base = (nsec); asm("":"=a" (__low), "=d" (__high):"A" (tmp)); __upper = __high; if (__high) { __upper = __high % (__base); __high = __high / (__base); } asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); asm("":"=A" (tmp):"a" (__low),"d" (__high)); __mod; });
> return (unsigned long) tmp;
>}
>
>
>extern unsigned long clockevent_delta2ns(unsigned long latch,
>      struct clock_event_device *evt);
>extern void clockevents_register_device(struct clock_event_device *dev);
>
>extern void clockevents_exchange_device(struct clock_event_device *old,
>     struct clock_event_device *new);
>extern void clockevents_set_mode(struct clock_event_device *dev,
>     enum clock_event_mode mode);
>extern int clockevents_register_notifier(struct notifier_block *nb);
>extern int clockevents_program_event(struct clock_event_device *dev,
>         ktime_t expires, ktime_t now);
>
>
>extern void clockevents_notify(unsigned long reason, void *arg);
># 10 "include/linux/tick.h" 2
>
>
>
>enum tick_device_mode {
> TICKDEV_MODE_PERIODIC,
> TICKDEV_MODE_ONESHOT,
>};
>
>struct tick_device {
> struct clock_event_device *evtdev;
> enum tick_device_mode mode;
>};
>
>enum tick_nohz_mode {
> NOHZ_MODE_INACTIVE,
> NOHZ_MODE_LOWRES,
> NOHZ_MODE_HIGHRES,
>};
># 45 "include/linux/tick.h"
>struct tick_sched {
> struct hrtimer sched_timer;
> unsigned long check_clocks;
> enum tick_nohz_mode nohz_mode;
> ktime_t idle_tick;
> int tick_stopped;
> unsigned long idle_jiffies;
> unsigned long idle_calls;
> unsigned long idle_sleeps;
> ktime_t idle_entrytime;
> ktime_t idle_sleeptime;
> ktime_t sleep_length;
> unsigned long last_jiffies;
> unsigned long next_jiffies;
> ktime_t idle_expires;
>};
>
>extern void __attribute__ ((__section__ (".init.text"))) tick_init(void);
>extern int tick_is_oneshot_available(void);
>extern struct tick_device *tick_get_device(int cpu);
>
>
>extern int tick_init_highres(void);
>extern int tick_program_event(ktime_t expires, int force);
>extern void tick_setup_sched_timer(void);
>extern void tick_cancel_sched_timer(int cpu);
>
>
>
>
>
>extern struct tick_device *tick_get_broadcast_device(void);
>extern cpumask_t *tick_get_broadcast_mask(void);
>
>
>extern cpumask_t *tick_get_broadcast_oneshot_mask(void);
>
>
>
>
>
>extern void tick_clock_notify(void);
>extern int tick_check_oneshot_change(int allow_nohz);
>extern struct tick_sched *tick_get_tick_sched(int cpu);
># 107 "include/linux/tick.h"
>static inline __attribute__((always_inline)) void tick_nohz_stop_sched_tick(void) { }
>static inline __attribute__((always_inline)) void tick_nohz_restart_sched_tick(void) { }
>static inline __attribute__((always_inline)) void tick_nohz_update_jiffies(void) { }
>static inline __attribute__((always_inline)) ktime_t tick_nohz_get_sleep_length(void)
>{
> ktime_t len = { .tv64 = 1000000000L/1000 };
>
> return len;
>}
># 44 "kernel/hrtimer.c" 2
># 1 "include/linux/seq_file.h" 1
># 9 "include/linux/seq_file.h"
>struct seq_operations;
>struct file;
>struct vfsmount;
>struct dentry;
>struct inode;
>
>struct seq_file {
> char *buf;
> size_t size;
> size_t from;
> size_t count;
> loff_t index;
> u64 version;
> struct mutex lock;
> const struct seq_operations *op;
> void *private;
>};
>
>struct seq_operations {
> void * (*start) (struct seq_file *m, loff_t *pos);
> void (*stop) (struct seq_file *m, void *v);
> void * (*next) (struct seq_file *m, void *v, loff_t *pos);
> int (*show) (struct seq_file *m, void *v);
>};
>
>int seq_open(struct file *, const struct seq_operations *);
>ssize_t seq_read(struct file *, char *, size_t, loff_t *);
>loff_t seq_lseek(struct file *, loff_t, int);
>int seq_release(struct inode *, struct file *);
>int seq_escape(struct seq_file *, const char *, const char *);
>int seq_putc(struct seq_file *m, char c);
>int seq_puts(struct seq_file *m, const char *s);
>
>int seq_printf(struct seq_file *, const char *, ...)
> __attribute__ ((format (printf,2,3)));
>
>int seq_path(struct seq_file *, struct vfsmount *, struct dentry *, char *);
>
>int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
>int single_release(struct inode *, struct file *);
>void *__seq_open_private(struct file *, const struct seq_operations *, int);
>int seq_open_private(struct file *, const struct seq_operations *, int);
>int seq_release_private(struct inode *, struct file *);
>
>
>
>
>
>
>
>extern struct list_head *seq_list_start(struct list_head *head,
>  loff_t pos);
>extern struct list_head *seq_list_start_head(struct list_head *head,
>  loff_t pos);
>extern struct list_head *seq_list_next(void *v, struct list_head *head,
>  loff_t *ppos);
># 45 "kernel/hrtimer.c" 2
># 1 "include/linux/err.h" 1
>
>
>
>
>
># 1 "include/asm/errno.h" 1
># 7 "include/linux/err.h" 2
># 22 "include/linux/err.h"
>static inline __attribute__((always_inline)) void *ERR_PTR(long error)
>{
> return (void *) error;
>}
>
>static inline __attribute__((always_inline)) long PTR_ERR(const void *ptr)
>{
> return (long) ptr;
>}
>
>static inline __attribute__((always_inline)) long IS_ERR(const void *ptr)
>{
> return __builtin_expect(!!(((unsigned long)ptr) >= (unsigned long)-4095), 0);
>}
># 46 "kernel/hrtimer.c" 2
>
># 1 "include/asm/uaccess.h" 1
>
># 1 "include/asm/uaccess_32.h" 1
># 11 "include/asm/uaccess_32.h"
># 1 "include/asm/page.h" 1
># 12 "include/asm/uaccess_32.h" 2
># 40 "include/asm/uaccess_32.h"
>extern struct movsl_mask {
> int mask;
>} __attribute__((__aligned__((1 << (7))))) movsl_mask;
># 98 "include/asm/uaccess_32.h"
>struct exception_table_entry
>{
> unsigned long insn, fixup;
>};
>
>extern int fixup_exception(struct pt_regs *regs);
># 120 "include/asm/uaccess_32.h"
>extern void __get_user_1(void);
>extern void __get_user_2(void);
>extern void __get_user_4(void);
># 162 "include/asm/uaccess_32.h"
>extern void __put_user_bad(void);
>
>
>
>
>
>extern void __put_user_1(void);
>extern void __put_user_2(void);
>extern void __put_user_4(void);
>extern void __put_user_8(void);
># 325 "include/asm/uaccess_32.h"
>struct __large_struct { unsigned long buf[100]; };
># 358 "include/asm/uaccess_32.h"
>extern long __get_user_bad(void);
># 389 "include/asm/uaccess_32.h"
>unsigned long __attribute__((warn_unused_result)) __copy_to_user_ll(void *to,
>    const void *from, unsigned long n);
>unsigned long __attribute__((warn_unused_result)) __copy_from_user_ll(void *to,
>    const void *from, unsigned long n);
>unsigned long __attribute__((warn_unused_result)) __copy_from_user_ll_nozero(void *to,
>    const void *from, unsigned long n);
>unsigned long __attribute__((warn_unused_result)) __copy_from_user_ll_nocache(void *to,
>    const void *from, unsigned long n);
>unsigned long __attribute__((warn_unused_result)) __copy_from_user_ll_nocache_nozero(void *to,
>    const void *from, unsigned long n);
># 419 "include/asm/uaccess_32.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long __attribute__((warn_unused_result))
>__copy_to_user_inatomic(void *to, const void *from, unsigned long n)
>{
> if (__builtin_constant_p(n)) {
>  unsigned long ret;
>
>  switch (n) {
>  case 1:
>   do { ret = 0; (void)0; switch (1) { case 1: __asm__ __volatile__( "1:	mov""b"" %""b""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "iq" (*(u8 *)from), "m"((*(struct __large_struct *)((u8 *)to))), "i"(1), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %""w""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "ir" (*(u8 *)from), "m"((*(struct __large_struct *)((u8 *)to))), "i"(1), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %""""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "ir" (*(u8 *)from), "m"((*(struct __large_struct *)((u8 *)to))), "i"(1), "0"(ret)); break; case 8: __asm__ __volatile__( "1:	movl %%eax,0(%2)\n" "2:	movl %%edx,4(%2)\n" "3:\n" ".section .fixup,\"ax\"\n" "4:	movl %3,%0\n" "	jmp 3b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,4b\n" "	.long 2b,4b\n" ".previous" : "=r"(ret) : "A" ((__typeof__(*(u8 *)to))(*(u8 *)from)), "r" ((u8 *)to), "i"(-14), "0"(ret)); break; default: __put_user_bad(); } } while (0);
>   return ret;
>  case 2:
>   do { ret = 0; (void)0; switch (2) { case 1: __asm__ __volatile__( "1:	mov""b"" %""b""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "iq" (*(u16 *)from), "m"((*(struct __large_struct *)((u16 *)to))), "i"(2), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %""w""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "ir" (*(u16 *)from), "m"((*(struct __large_struct *)((u16 *)to))), "i"(2), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %""""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "ir" (*(u16 *)from), "m"((*(struct __large_struct *)((u16 *)to))), "i"(2), "0"(ret)); break; case 8: __asm__ __volatile__( "1:	movl %%eax,0(%2)\n" "2:	movl %%edx,4(%2)\n" "3:\n" ".section .fixup,\"ax\"\n" "4:	movl %3,%0\n" "	jmp 3b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,4b\n" "	.long 2b,4b\n" ".previous" : "=r"(ret) : "A" ((__typeof__(*(u16 *)to))(*(u16 *)from)), "r" ((u16 *)to), "i"(-14), "0"(ret)); break; default: __put_user_bad(); } } while (0);
>   return ret;
>  case 4:
>   do { ret = 0; (void)0; switch (4) { case 1: __asm__ __volatile__( "1:	mov""b"" %""b""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "iq" (*(u32 *)from), "m"((*(struct __large_struct *)((u32 *)to))), "i"(4), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %""w""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "ir" (*(u32 *)from), "m"((*(struct __large_struct *)((u32 *)to))), "i"(4), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %""""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret) : "ir" (*(u32 *)from), "m"((*(struct __large_struct *)((u32 *)to))), "i"(4), "0"(ret)); break; case 8: __asm__ __volatile__( "1:	movl %%eax,0(%2)\n" "2:	movl %%edx,4(%2)\n" "3:\n" ".section .fixup,\"ax\"\n" "4:	movl %3,%0\n" "	jmp 3b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,4b\n" "	.long 2b,4b\n" ".previous" : "=r"(ret) : "A" ((__typeof__(*(u32 *)to))(*(u32 *)from)), "r" ((u32 *)to), "i"(-14), "0"(ret)); break; default: __put_user_bad(); } } while (0);
>   return ret;
>  }
> }
> return __copy_to_user_ll(to, from, n);
>}
># 454 "include/asm/uaccess_32.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long __attribute__((warn_unused_result))
>__copy_to_user(void *to, const void *from, unsigned long n)
>{
>       do { cond_resched(); } while (0);
>       return __copy_to_user_inatomic(to, from, n);
>}
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long
>__copy_from_user_inatomic(void *to, const void *from, unsigned long n)
>{
>
>
>
>
>
> if (__builtin_constant_p(n)) {
>  unsigned long ret;
>
>  switch (n) {
>  case 1:
>   do { ret = 0; (void)0; switch (1) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; default: (*(u8 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  case 2:
>   do { ret = 0; (void)0; switch (2) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; default: (*(u16 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  case 4:
>   do { ret = 0; (void)0; switch (4) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; default: (*(u32 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  }
> }
> return __copy_from_user_ll_nozero(to, from, n);
>}
># 509 "include/asm/uaccess_32.h"
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long
>__copy_from_user(void *to, const void *from, unsigned long n)
>{
> do { cond_resched(); } while (0);
> if (__builtin_constant_p(n)) {
>  unsigned long ret;
>
>  switch (n) {
>  case 1:
>   do { ret = 0; (void)0; switch (1) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; default: (*(u8 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  case 2:
>   do { ret = 0; (void)0; switch (2) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; default: (*(u16 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  case 4:
>   do { ret = 0; (void)0; switch (4) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; default: (*(u32 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  }
> }
> return __copy_from_user_ll(to, from, n);
>}
>
>
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long __copy_from_user_nocache(void *to,
>    const void *from, unsigned long n)
>{
> do { cond_resched(); } while (0);
> if (__builtin_constant_p(n)) {
>  unsigned long ret;
>
>  switch (n) {
>  case 1:
>   do { ret = 0; (void)0; switch (1) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u8 *)to) : "m"((*(struct __large_struct *)(from))), "i"(1), "0"(ret));break; default: (*(u8 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  case 2:
>   do { ret = 0; (void)0; switch (2) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u16 *)to) : "m"((*(struct __large_struct *)(from))), "i"(2), "0"(ret));break; default: (*(u16 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  case 4:
>   do { ret = 0; (void)0; switch (4) { case 1: __asm__ __volatile__( "1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=q" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; case 2: __asm__ __volatile__( "1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; case 4: __asm__ __volatile__( "1:	mov""l"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	movl %3,%0\n" "	xor""l"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" ".section __ex_table,\"a\"\n" "	.align 4\n" "	.long 1b,3b\n" ".previous" : "=r"(ret), "=r" (*(u32 *)to) : "m"((*(struct __large_struct *)(from))), "i"(4), "0"(ret));break; default: (*(u32 *)to) = __get_user_bad(); } } while (0);
>   return ret;
>  }
> }
> return __copy_from_user_ll_nocache(to, from, n);
>}
>
>static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned long
>__copy_from_user_inatomic_nocache(void *to, const void *from, unsigned long n)
>{
>       return __copy_from_user_ll_nocache_nozero(to, from, n);
>}
>
>unsigned long __attribute__((warn_unused_result)) copy_to_user(void *to,
>    const void *from, unsigned long n);
>unsigned long __attribute__((warn_unused_result)) copy_from_user(void *to,
>    const void *from, unsigned long n);
>long __attribute__((warn_unused_result)) strncpy_from_user(char *dst, const char *src,
>    long count);
>long __attribute__((warn_unused_result)) __strncpy_from_user(char *dst,
>    const char *src, long count);
># 586 "include/asm/uaccess_32.h"
>long strnlen_user(const char *str, long n);
>unsigned long __attribute__((warn_unused_result)) clear_user(void *mem, unsigned long len);
>unsigned long __attribute__((warn_unused_result)) __clear_user(void *mem, unsigned long len);
># 3 "include/asm/uaccess.h" 2
># 48 "kernel/hrtimer.c" 2
>
>
>
>
>
>
>ktime_t ktime_get(void)
>{
> struct timespec now;
>
> ktime_get_ts(&now);
>
> return timespec_to_ktime(now);
>}
>extern typeof(ktime_get) ktime_get; extern void *__crc_ktime_get __attribute__((weak)); static const unsigned long __kcrctab_ktime_get __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_ktime_get; static const char __kstrtab_ktime_get[] __attribute__((section("__ksymtab_strings"))) = "" "ktime_get"; static const struct kernel_symbol __ksymtab_ktime_get __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&ktime_get, __kstrtab_ktime_get };
>
>
>
>
>
>
>ktime_t ktime_get_real(void)
>{
> struct timespec now;
>
> getnstimeofday(&now);
>
> return timespec_to_ktime(now);
>}
>
>extern typeof(ktime_get_real) ktime_get_real; extern void *__crc_ktime_get_real __attribute__((weak)); static const unsigned long __kcrctab_ktime_get_real __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_ktime_get_real; static const char __kstrtab_ktime_get_real[] __attribute__((section("__ksymtab_strings"))) = "" "ktime_get_real"; static const struct kernel_symbol __ksymtab_ktime_get_real __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&ktime_get_real, __kstrtab_ktime_get_real };
># 89 "kernel/hrtimer.c"
>__attribute__((__section__(".data.percpu"))) __typeof__(struct hrtimer_cpu_base) per_cpu__hrtimer_bases =
>{
>
> .clock_base =
> {
>  {
>   .index = 0,
>   .get_time = &ktime_get_real,
>   .resolution = (ktime_t){ .tv64 = (( (((1000000UL * 1000) / ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000)))))) << (8)) + ((((1000000UL * 1000) % ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000)))))) << (8)) + ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000))))) / 2) / ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000))))))) },
>  },
>  {
>   .index = 1,
>   .get_time = &ktime_get,
>   .resolution = (ktime_t){ .tv64 = (( (((1000000UL * 1000) / ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000)))))) << (8)) + ((((1000000UL * 1000) % ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000)))))) << (8)) + ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000))))) / 2) / ((( (((1193182) / (((1193182 + 1000/2) / 1000))) << (8)) + ((((1193182) % (((1193182 + 1000/2) / 1000))) << (8)) + (((1193182 + 1000/2) / 1000)) / 2) / (((1193182 + 1000/2) / 1000))))))) },
>  },
> }
>};
># 115 "kernel/hrtimer.c"
>void ktime_get_ts(struct timespec *ts)
>{
> struct timespec tomono;
> unsigned long seq;
>
> do {
>  seq = read_seqbegin(&xtime_lock);
>  getnstimeofday(ts);
>  tomono = wall_to_monotonic;
>
> } while (read_seqretry(&xtime_lock, seq));
>
> set_normalized_timespec(ts, ts->tv_sec + tomono.tv_sec,
>    ts->tv_nsec + tomono.tv_nsec);
>}
>extern typeof(ktime_get_ts) ktime_get_ts; extern void *__crc_ktime_get_ts __attribute__((weak)); static const unsigned long __kcrctab_ktime_get_ts __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_ktime_get_ts; static const char __kstrtab_ktime_get_ts[] __attribute__((section("__ksymtab_strings"))) = "" "ktime_get_ts"; static const struct kernel_symbol __ksymtab_ktime_get_ts __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&ktime_get_ts, __kstrtab_ktime_get_ts };
>
>
>
>
>
>static void hrtimer_get_softirq_time(struct hrtimer_cpu_base *base)
>{
> ktime_t xtim, tomono;
> struct timespec xts, tom;
> unsigned long seq;
>
> do {
>  seq = read_seqbegin(&xtime_lock);
>  xts = current_kernel_time();
>  tom = wall_to_monotonic;
> } while (read_seqretry(&xtime_lock, seq));
>
> xtim = timespec_to_ktime(xts);
> tomono = timespec_to_ktime(tom);
> base->clock_base[0].softirq_time = xtim;
> base->clock_base[1].softirq_time =
>  ({ (ktime_t){ .tv64 = (xtim).tv64 + (tomono).tv64 }; });
>}
>
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_callback_running(struct hrtimer *timer)
>{
> return timer->state & 0x02;
>}
># 182 "kernel/hrtimer.c"
>static
>struct hrtimer_clock_base *lock_hrtimer_base(const struct hrtimer *timer,
>          unsigned long *flags)
>{
> struct hrtimer_clock_base *base;
>
> for (;;) {
>  base = timer->base;
>  if (__builtin_expect(!!(base != ((void *)0)), 1)) {
>   *flags = _spin_lock_irqsave(&base->cpu_base->lock);
>   if (__builtin_expect(!!(base == timer->base), 1))
>    return base;
>
>   _spin_unlock_irqrestore(&base->cpu_base->lock, *flags);
>  }
>  rep_nop();
> }
>}
>
>
>
>
>static inline __attribute__((always_inline)) struct hrtimer_clock_base *
>switch_hrtimer_base(struct hrtimer *timer, struct hrtimer_clock_base *base)
>{
> struct hrtimer_clock_base *new_base;
> struct hrtimer_cpu_base *new_cpu_base;
>
> new_cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
> new_base = &new_cpu_base->clock_base[base->index];
>
> if (base != new_base) {
># 223 "kernel/hrtimer.c"
>  if (__builtin_expect(!!(hrtimer_callback_running(timer)), 0))
>   return base;
>
>
>  timer->base = ((void *)0);
>  do {__raw_spin_unlock(&(&base->cpu_base->lock)->raw_lock); (void)0; } while (0);
>  _spin_lock(&new_base->cpu_base->lock);
>  timer->base = new_base;
> }
> return new_base;
>}
># 309 "kernel/hrtimer.c"
>unsigned long ktime_divns(const ktime_t kt, s64 div)
>{
> u64 dclc, inc, dns;
> int sft = 0;
>
> dclc = dns = ((kt).tv64);
> inc = div;
>
> while (div >> 32) {
>  sft++;
>  div >>= 1;
> }
> dclc >>= sft;
> ({ unsigned long __upper, __low, __high, __mod, __base; __base = ((unsigned long) div); asm("":"=a" (__low), "=d" (__high):"A" (dclc)); __upper = __high; if (__high) { __upper = __high % (__base); __high = __high / (__base); } asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); asm("":"=A" (dclc):"a" (__low),"d" (__high)); __mod; });
>
> return (unsigned long) dclc;
>}
># 334 "kernel/hrtimer.c"
>static int hrtimer_hres_enabled __attribute__((__section__(".data.read_mostly"))) = 1;
>
>
>
>
>static int __attribute__ ((__section__ (".init.text"))) setup_hrtimer_hres(char *str)
>{
> if (!strcmp(str, "off"))
>  hrtimer_hres_enabled = 0;
> else if (!strcmp(str, "on"))
>  hrtimer_hres_enabled = 1;
> else
>  return 0;
> return 1;
>}
>
>static char __setup_str_setup_hrtimer_hres[] __attribute__ ((__section__ (".init.data"))) __attribute__((aligned(1))) = "highres="; static struct obs_kernel_param __setup_setup_hrtimer_hres __attribute__((__used__)) __attribute__((__section__(".init.setup"))) __attribute__((aligned((sizeof(long))))) = { __setup_str_setup_hrtimer_hres, setup_hrtimer_hres, 0 };
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_is_hres_enabled(void)
>{
> return hrtimer_hres_enabled;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_hres_active(void)
>{
> return (*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); })).hres_active;
>}
>
>
>
>
>
>
>static void hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base)
>{
> int i;
> struct hrtimer_clock_base *base = cpu_base->clock_base;
> ktime_t expires;
>
> cpu_base->expires_next.tv64 = ((s64)~((u64)1 << 63));
>
> for (i = 0; i < 2; i++, base++) {
>  struct hrtimer *timer;
>
>  if (!base->first)
>   continue;
>  timer = ({ const typeof( ((struct hrtimer *)0)->node ) *__mptr = (base->first); (struct hrtimer *)( (char *)__mptr - __builtin_offsetof(struct hrtimer,node) );});
>  expires = ({ (ktime_t){ .tv64 = (timer->expires).tv64 - (base->offset).tv64 }; });
>  if (expires.tv64 < cpu_base->expires_next.tv64)
>   cpu_base->expires_next = expires;
> }
>
> if (cpu_base->expires_next.tv64 != ((s64)~((u64)1 << 63)))
>  tick_program_event(cpu_base->expires_next, 1);
>}
># 405 "kernel/hrtimer.c"
>static int hrtimer_reprogram(struct hrtimer *timer,
>        struct hrtimer_clock_base *base)
>{
> ktime_t *expires_next = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); })).expires_next;
> ktime_t expires = ({ (ktime_t){ .tv64 = (timer->expires).tv64 - (base->offset).tv64 }; });
> int res;
># 419 "kernel/hrtimer.c"
> if (hrtimer_callback_running(timer))
>  return 0;
>
> if (expires.tv64 >= expires_next->tv64)
>  return 0;
>
>
>
>
> res = tick_program_event(expires, 0);
> if (!__builtin_expect(!!((res) >= (unsigned long)-4095), 0))
>  *expires_next = expires;
> return res;
>}
>
>
>
>
>
>
>
>static void retrigger_next_event(void *arg)
>{
> struct hrtimer_cpu_base *base;
> struct timespec realtime_offset;
> unsigned long seq;
>
> if (!hrtimer_hres_active())
>  return;
>
> do {
>  seq = read_seqbegin(&xtime_lock);
>  set_normalized_timespec(&realtime_offset,
>     -wall_to_monotonic.tv_sec,
>     -wall_to_monotonic.tv_nsec);
> } while (read_seqretry(&xtime_lock, seq));
>
> base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
>
>
> _spin_lock(&base->lock);
> base->clock_base[0].offset =
>  timespec_to_ktime(realtime_offset);
>
> hrtimer_force_reprogram(base);
> do {__raw_spin_unlock(&(&base->lock)->raw_lock); (void)0; } while (0);
>}
># 478 "kernel/hrtimer.c"
>void clock_was_set(void)
>{
>
> on_each_cpu(retrigger_next_event, ((void *)0), 0, 1);
>}
>
>
>
>
>
>void hres_timers_resume(void)
>{
> ({ static int __warned; int __ret_warn_once = !!(__cpus_weight(&(cpu_online_map), 32) > 1); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) { printk("WARNING: at %s:%d %s()\n", "kernel/hrtimer.c", 490, (__func__)); dump_stack(); } __builtin_expect(!!(__ret_warn_on), 0); })) __warned = 1; __builtin_expect(!!(__ret_warn_once), 0); });
>
>
> retrigger_next_event(((void *)0));
>}
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_cb_pending(const struct hrtimer *timer)
>{
> return timer->state & 0x04;
>}
>
>
>
>
>static inline __attribute__((always_inline)) void hrtimer_remove_cb_pending(struct hrtimer *timer)
>{
> list_del_init(&timer->cb_entry);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void hrtimer_init_hres(struct hrtimer_cpu_base *base)
>{
> base->expires_next.tv64 = ((s64)~((u64)1 << 63));
> base->hres_active = 0;
> INIT_LIST_HEAD(&base->cb_pending);
>}
>
>
>
>
>static inline __attribute__((always_inline)) void hrtimer_init_timer_hres(struct hrtimer *timer)
>{
> INIT_LIST_HEAD(&timer->cb_entry);
>}
>
>
>
>
>
>
>
>static inline __attribute__((always_inline)) int hrtimer_enqueue_reprogram(struct hrtimer *timer,
>         struct hrtimer_clock_base *base)
>{
> if (base->cpu_base->hres_active && hrtimer_reprogram(timer, base)) {
>
>
>  switch(timer->cb_mode) {
>  case HRTIMER_CB_IRQSAFE_NO_RESTART:
>
>
>
>
>   do { if (__builtin_expect(!!(timer->function(timer) != HRTIMER_NORESTART), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (548), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
>   return 1;
>  case HRTIMER_CB_IRQSAFE_NO_SOFTIRQ:
>
>
>
>
>
>
>
>   return 1;
>  case HRTIMER_CB_IRQSAFE:
>  case HRTIMER_CB_SOFTIRQ:
>
>
>
>   list_add_tail(&timer->cb_entry,
>          &base->cpu_base->cb_pending);
>   timer->state = 0x04;
>   raise_softirq(HRTIMER_SOFTIRQ);
>   return 1;
>  default:
>   do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (570), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0);
>  }
> }
> return 0;
>}
>
>
>
>
>static int hrtimer_switch_to_hres(void)
>{
> int cpu = (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; }));
> struct hrtimer_cpu_base *base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (__per_cpu_offset[cpu])); }); }));
> unsigned long flags;
>
> if (base->hres_active)
>  return 1;
>
> do { do { (flags) = __raw_local_irq_save(); } while (0); do { } while (0); } while (0);
>
> if (tick_init_highres()) {
>  do { if (raw_irqs_disabled_flags(flags)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
>  printk("<4>" "Could not switch to high resolution "
>        "mode on CPU %d\n", cpu);
>  return 0;
> }
> base->hres_active = 1;
> base->clock_base[0].resolution = (ktime_t) { .tv64 = 1 };
> base->clock_base[1].resolution = (ktime_t) { .tv64 = 1 };
>
> tick_setup_sched_timer();
>
>
> retrigger_next_event(((void *)0));
> do { if (raw_irqs_disabled_flags(flags)) { raw_local_irq_restore(flags); do { } while (0); } else { do { } while (0); raw_local_irq_restore(flags); } } while (0);
> printk("<7>" "Switched to high resolution mode on CPU %d\n",
>        (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; })));
> return 1;
>}
># 643 "kernel/hrtimer.c"
>static inline __attribute__((always_inline))
>void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
>{
> _spin_unlock_irqrestore(&timer->base->cpu_base->lock, *flags);
>}
># 658 "kernel/hrtimer.c"
>unsigned long
>hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)
>{
> unsigned long orun = 1;
> ktime_t delta;
>
> delta = ({ (ktime_t){ .tv64 = (now).tv64 - (timer->expires).tv64 }; });
>
> if (delta.tv64 < 0)
>  return 0;
>
> if (interval.tv64 < timer->base->resolution.tv64)
>  interval.tv64 = timer->base->resolution.tv64;
>
> if (__builtin_expect(!!(delta.tv64 >= interval.tv64), 0)) {
>  s64 incr = ((interval).tv64);
>
>  orun = ktime_divns(delta, incr);
>  timer->expires = ({ (ktime_t){ .tv64 = (timer->expires).tv64 + (incr * orun) }; });
>  if (timer->expires.tv64 > now.tv64)
>   return orun;
>
>
>
>
>  orun++;
> }
> timer->expires = ({ (ktime_t){ .tv64 = (timer->expires).tv64 + (interval).tv64 }; });
>
>
>
>
> if (timer->expires.tv64 < 0)
>  timer->expires = ktime_set(((long)(~0UL>>1)), 0);
>
> return orun;
>}
>extern typeof(hrtimer_forward) hrtimer_forward; extern void *__crc_hrtimer_forward __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_forward __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_forward; static const char __kstrtab_hrtimer_forward[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_forward"; static const struct kernel_symbol __ksymtab_hrtimer_forward __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_forward, __kstrtab_hrtimer_forward };
>
>
>
>
>
>
>
>static void enqueue_hrtimer(struct hrtimer *timer,
>       struct hrtimer_clock_base *base, int reprogram)
>{
> struct rb_node **link = &base->active.rb_node;
> struct rb_node *parent = ((void *)0);
> struct hrtimer *entry;
> int leftmost = 1;
>
>
>
>
> while (*link) {
>  parent = *link;
>  entry = ({ const typeof( ((struct hrtimer *)0)->node ) *__mptr = (parent); (struct hrtimer *)( (char *)__mptr - __builtin_offsetof(struct hrtimer,node) );});
>
>
>
>
>  if (timer->expires.tv64 < entry->expires.tv64) {
>   link = &(*link)->rb_left;
>  } else {
>   link = &(*link)->rb_right;
>   leftmost = 0;
>  }
> }
>
>
>
>
>
> if (leftmost) {
># 742 "kernel/hrtimer.c"
>  if (reprogram && hrtimer_enqueue_reprogram(timer, base))
>   return;
>
>  base->first = &timer->node;
> }
>
> rb_link_node(&timer->node, parent, link);
> rb_insert_color(&timer->node, &base->active);
>
>
>
>
> timer->state |= 0x01;
>}
># 767 "kernel/hrtimer.c"
>static void __remove_hrtimer(struct hrtimer *timer,
>        struct hrtimer_clock_base *base,
>        unsigned long newstate, int reprogram)
>{
>
> if (hrtimer_cb_pending(timer))
>  hrtimer_remove_cb_pending(timer);
> else {
>
>
>
>
>  if (base->first == &timer->node) {
>   base->first = rb_next(&timer->node);
>
>   if (reprogram && hrtimer_hres_active())
>    hrtimer_force_reprogram(base->cpu_base);
>  }
>  rb_erase(&timer->node, &base->active);
> }
> timer->state = newstate;
>}
>
>
>
>
>static inline __attribute__((always_inline)) int
>remove_hrtimer(struct hrtimer *timer, struct hrtimer_clock_base *base)
>{
> if (hrtimer_is_queued(timer)) {
>  int reprogram;
># 807 "kernel/hrtimer.c"
>  timer_stats_hrtimer_clear_start_info(timer);
>  reprogram = base->cpu_base == &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
>  __remove_hrtimer(timer, base, 0x00,
>     reprogram);
>  return 1;
> }
> return 0;
>}
># 826 "kernel/hrtimer.c"
>int
>hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
>{
> struct hrtimer_clock_base *base, *new_base;
> unsigned long flags;
> int ret;
>
> base = lock_hrtimer_base(timer, &flags);
>
>
> ret = remove_hrtimer(timer, base);
>
>
> new_base = switch_hrtimer_base(timer, base);
>
> if (mode == HRTIMER_MODE_REL) {
>  tim = ({ (ktime_t){ .tv64 = (tim).tv64 + (new_base->get_time()).tv64 }; });
># 853 "kernel/hrtimer.c"
> }
> timer->expires = tim;
>
> timer_stats_hrtimer_set_start_info(timer);
>
>
>
>
>
> enqueue_hrtimer(timer, new_base,
>   new_base->cpu_base == &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); })));
>
> unlock_hrtimer_base(timer, &flags);
>
> return ret;
>}
>extern typeof(hrtimer_start) hrtimer_start; extern void *__crc_hrtimer_start __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_start __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_start; static const char __kstrtab_hrtimer_start[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_start"; static const struct kernel_symbol __ksymtab_hrtimer_start __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_start, __kstrtab_hrtimer_start };
># 881 "kernel/hrtimer.c"
>int hrtimer_try_to_cancel(struct hrtimer *timer)
>{
> struct hrtimer_clock_base *base;
> unsigned long flags;
> int ret = -1;
>
> base = lock_hrtimer_base(timer, &flags);
>
> if (!hrtimer_callback_running(timer))
>  ret = remove_hrtimer(timer, base);
>
> unlock_hrtimer_base(timer, &flags);
>
> return ret;
>
>}
>extern typeof(hrtimer_try_to_cancel) hrtimer_try_to_cancel; extern void *__crc_hrtimer_try_to_cancel __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_try_to_cancel __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_try_to_cancel; static const char __kstrtab_hrtimer_try_to_cancel[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_try_to_cancel"; static const struct kernel_symbol __ksymtab_hrtimer_try_to_cancel __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_try_to_cancel, __kstrtab_hrtimer_try_to_cancel };
># 907 "kernel/hrtimer.c"
>int hrtimer_cancel(struct hrtimer *timer)
>{
> for (;;) {
>  int ret = hrtimer_try_to_cancel(timer);
>
>  if (ret >= 0)
>   return ret;
>  rep_nop();
> }
>}
>extern typeof(hrtimer_cancel) hrtimer_cancel; extern void *__crc_hrtimer_cancel __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_cancel __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_cancel; static const char __kstrtab_hrtimer_cancel[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_cancel"; static const struct kernel_symbol __ksymtab_hrtimer_cancel __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_cancel, __kstrtab_hrtimer_cancel };
>
>
>
>
>
>ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
>{
> struct hrtimer_clock_base *base;
> unsigned long flags;
> ktime_t rem;
>
> base = lock_hrtimer_base(timer, &flags);
> rem = ({ (ktime_t){ .tv64 = (timer->expires).tv64 - (base->get_time()).tv64 }; });
> unlock_hrtimer_base(timer, &flags);
>
> return rem;
>}
>extern typeof(hrtimer_get_remaining) hrtimer_get_remaining; extern void *__crc_hrtimer_get_remaining __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_get_remaining __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_get_remaining; static const char __kstrtab_hrtimer_get_remaining[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_get_remaining"; static const struct kernel_symbol __ksymtab_hrtimer_get_remaining __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_get_remaining, __kstrtab_hrtimer_get_remaining };
># 983 "kernel/hrtimer.c"
>void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
>    enum hrtimer_mode mode)
>{
> struct hrtimer_cpu_base *cpu_base;
>
> (__builtin_constant_p(0) ? (__builtin_constant_p((sizeof(struct hrtimer))) ? __constant_c_and_count_memset(((timer)),((0x01010101UL*(unsigned char)(0))),((sizeof(struct hrtimer)))) : __constant_c_memset(((timer)),((0x01010101UL*(unsigned char)(0))),((sizeof(struct hrtimer))))) : (__builtin_constant_p((sizeof(struct hrtimer))) ? __memset_generic((((timer))),(((0))),(((sizeof(struct hrtimer))))) : __memset_generic(((timer)),((0)),((sizeof(struct hrtimer))))));
>
> cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
>
> if (clock_id == 0 && mode != HRTIMER_MODE_ABS)
>  clock_id = 1;
>
> timer->base = &cpu_base->clock_base[clock_id];
> hrtimer_init_timer_hres(timer);
>
>
>
>
>
>
>}
>extern typeof(hrtimer_init) hrtimer_init; extern void *__crc_hrtimer_init __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_init __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_init; static const char __kstrtab_hrtimer_init[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_init"; static const struct kernel_symbol __ksymtab_hrtimer_init __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_init, __kstrtab_hrtimer_init };
># 1014 "kernel/hrtimer.c"
>int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
>{
> struct hrtimer_cpu_base *cpu_base;
>
> cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
> *tp = ns_to_timespec((cpu_base->clock_base[which_clock].resolution).tv64);
>
> return 0;
>}
>extern typeof(hrtimer_get_res) hrtimer_get_res; extern void *__crc_hrtimer_get_res __attribute__((weak)); static const unsigned long __kcrctab_hrtimer_get_res __attribute__((__used__)) __attribute__((section("__kcrctab" "_gpl"), unused)) = (unsigned long) &__crc_hrtimer_get_res; static const char __kstrtab_hrtimer_get_res[] __attribute__((section("__ksymtab_strings"))) = "" "hrtimer_get_res"; static const struct kernel_symbol __ksymtab_hrtimer_get_res __attribute__((__used__)) __attribute__((section("__ksymtab" "_gpl"), unused)) = { (unsigned long)&hrtimer_get_res, __kstrtab_hrtimer_get_res };
>
>
>
>
>
>
>
>void hrtimer_interrupt(struct clock_event_device *dev)
>{
> struct hrtimer_cpu_base *cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
> struct hrtimer_clock_base *base;
> ktime_t expires_next, now;
> int i, raise = 0;
>
> do { if (__builtin_expect(!!(!cpu_base->hres_active), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (1038), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
> cpu_base->nr_events++;
> dev->next_event.tv64 = ((s64)~((u64)1 << 63));
>
> retry:
> now = ktime_get();
>
> expires_next.tv64 = ((s64)~((u64)1 << 63));
>
> base = cpu_base->clock_base;
>
> for (i = 0; i < 2; i++) {
>  ktime_t basenow;
>  struct rb_node *node;
>
>  _spin_lock(&cpu_base->lock);
>
>  basenow = ({ (ktime_t){ .tv64 = (now).tv64 + (base->offset).tv64 }; });
>
>  while ((node = base->first)) {
>   struct hrtimer *timer;
>
>   timer = ({ const typeof( ((struct hrtimer *)0)->node ) *__mptr = (node); (struct hrtimer *)( (char *)__mptr - __builtin_offsetof(struct hrtimer,node) );});
>
>   if (basenow.tv64 < timer->expires.tv64) {
>    ktime_t expires;
>
>    expires = ({ (ktime_t){ .tv64 = (timer->expires).tv64 - (base->offset).tv64 }; });
>
>    if (expires.tv64 < expires_next.tv64)
>     expires_next = expires;
>    break;
>   }
>
>
>   if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {
>    __remove_hrtimer(timer, base,
>       0x04, 0);
>    list_add_tail(&timer->cb_entry,
>           &base->cpu_base->cb_pending);
>    raise = 1;
>    continue;
>   }
>
>   __remove_hrtimer(timer, base,
>      0x02, 0);
>   timer_stats_account_hrtimer(timer);
>
>
>
>
>
>
>
>   if (timer->function(timer) != HRTIMER_NORESTART) {
>    do { if (__builtin_expect(!!(timer->state != 0x02), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (1093), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
>    enqueue_hrtimer(timer, base, 0);
>   }
>   timer->state &= ~0x02;
>  }
>  do {__raw_spin_unlock(&(&cpu_base->lock)->raw_lock); (void)0; } while (0);
>  base++;
> }
>
> cpu_base->expires_next = expires_next;
>
>
> if (expires_next.tv64 != ((s64)~((u64)1 << 63))) {
>  if (tick_program_event(expires_next, 0))
>   goto retry;
> }
>
>
> if (raise)
>  raise_softirq(HRTIMER_SOFTIRQ);
>}
>
>static void run_hrtimer_softirq(struct softirq_action *h)
>{
> struct hrtimer_cpu_base *cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
>
> _spin_lock_irq(&cpu_base->lock);
>
> while (!list_empty(&cpu_base->cb_pending)) {
>  enum hrtimer_restart (*fn)(struct hrtimer *);
>  struct hrtimer *timer;
>  int restart;
>
>  timer = ({ const typeof( ((struct hrtimer *)0)->cb_entry ) *__mptr = (cpu_base->cb_pending.next); (struct hrtimer *)( (char *)__mptr - __builtin_offsetof(struct hrtimer,cb_entry) );});
>
>
>  timer_stats_account_hrtimer(timer);
>
>  fn = timer->function;
>  __remove_hrtimer(timer, timer->base, 0x02, 0);
>  do { __raw_spin_unlock(&(&cpu_base->lock)->raw_lock); (void)0; do { do { } while (0); raw_local_irq_enable(); } while (0); } while (0);
>
>  restart = fn(timer);
>
>  _spin_lock_irq(&cpu_base->lock);
>
>  timer->state &= ~0x02;
>  if (restart == HRTIMER_RESTART) {
>   do { if (__builtin_expect(!!(hrtimer_active(timer)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (1141), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
>
>
>
>
>   enqueue_hrtimer(timer, timer->base, 1);
>  } else if (hrtimer_active(timer)) {
>
>
>
>
>   if (timer->base->first == &timer->node)
>    hrtimer_reprogram(timer, timer->base);
>  }
> }
> do { __raw_spin_unlock(&(&cpu_base->lock)->raw_lock); (void)0; do { do { } while (0); raw_local_irq_enable(); } while (0); } while (0);
>}
>
>
>
>
>
>
>static inline __attribute__((always_inline)) void run_hrtimer_queue(struct hrtimer_cpu_base *cpu_base,
>         int index)
>{
> struct rb_node *node;
> struct hrtimer_clock_base *base = &cpu_base->clock_base[index];
>
> if (!base->first)
>  return;
>
> if (base->get_softirq_time)
>  base->softirq_time = base->get_softirq_time();
>
> _spin_lock_irq(&cpu_base->lock);
>
> while ((node = base->first)) {
>  struct hrtimer *timer;
>  enum hrtimer_restart (*fn)(struct hrtimer *);
>  int restart;
>
>  timer = ({ const typeof( ((struct hrtimer *)0)->node ) *__mptr = (node); (struct hrtimer *)( (char *)__mptr - __builtin_offsetof(struct hrtimer,node) );});
>  if (base->softirq_time.tv64 <= timer->expires.tv64)
>   break;
>
>
>  ({ static int __warned; int __ret_warn_once = !!(timer->cb_mode == HRTIMER_CB_IRQSAFE_NO_SOFTIRQ); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) { printk("WARNING: at %s:%d %s()\n", "kernel/hrtimer.c", 1188, (__func__)); dump_stack(); } __builtin_expect(!!(__ret_warn_on), 0); })) __warned = 1; __builtin_expect(!!(__ret_warn_once), 0); });
>
>  timer_stats_account_hrtimer(timer);
>
>  fn = timer->function;
>  __remove_hrtimer(timer, base, 0x02, 0);
>  do { __raw_spin_unlock(&(&cpu_base->lock)->raw_lock); (void)0; do { do { } while (0); raw_local_irq_enable(); } while (0); } while (0);
>
>  restart = fn(timer);
>
>  _spin_lock_irq(&cpu_base->lock);
>
>  timer->state &= ~0x02;
>  if (restart != HRTIMER_NORESTART) {
>   do { if (__builtin_expect(!!(hrtimer_active(timer)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (1202), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
>   enqueue_hrtimer(timer, base, 0);
>  }
> }
> do { __raw_spin_unlock(&(&cpu_base->lock)->raw_lock); (void)0; do { do { } while (0); raw_local_irq_enable(); } while (0); } while (0);
>}
># 1216 "kernel/hrtimer.c"
>void hrtimer_run_queues(void)
>{
> struct hrtimer_cpu_base *cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); }));
> int i;
>
> if (hrtimer_hres_active())
>  return;
># 1232 "kernel/hrtimer.c"
> if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
>  if (hrtimer_switch_to_hres())
>   return;
>
> hrtimer_get_softirq_time(cpu_base);
>
> for (i = 0; i < 2; i++)
>  run_hrtimer_queue(cpu_base, i);
>}
>
>
>
>
>static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer)
>{
> struct hrtimer_sleeper *t =
>  ({ const typeof( ((struct hrtimer_sleeper *)0)->timer ) *__mptr = (timer); (struct hrtimer_sleeper *)( (char *)__mptr - __builtin_offsetof(struct hrtimer_sleeper,timer) );});
> struct task_struct *task = t->task;
>
> t->task = ((void *)0);
> if (task)
>  wake_up_process(task);
>
> return HRTIMER_NORESTART;
>}
>
>void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
>{
> sl->timer.function = hrtimer_wakeup;
> sl->task = task;
>
> sl->timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_RESTART;
>
>}
>
>static int __attribute__((__section__(".sched.text"))) do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
>{
> hrtimer_init_sleeper(t, get_current());
>
> do {
>  do { (void) ((__typeof__(*(&get_current()->state)))__xchg((unsigned long)((1)),(&get_current()->state),sizeof(*(&get_current()->state)))); } while (0);
>  hrtimer_start(&t->timer, t->timer.expires, mode);
>
>  if (__builtin_expect(!!(t->task), 1))
>   schedule();
>
>  hrtimer_cancel(&t->timer);
>  mode = HRTIMER_MODE_ABS;
>
> } while (t->task && !signal_pending(get_current()));
>
> return t->task == ((void *)0);
>}
>
>long __attribute__((__section__(".sched.text"))) hrtimer_nanosleep_restart(struct restart_block *restart)
>{
> struct hrtimer_sleeper t;
> struct timespec *rmtp;
> ktime_t time;
>
> restart->fn = do_no_restart_syscall;
>
> hrtimer_init(&t.timer, restart->arg0, HRTIMER_MODE_ABS);
> t.timer.expires.tv64 = ((u64)restart->arg3 << 32) | (u64) restart->arg2;
>
> if (do_nanosleep(&t, HRTIMER_MODE_ABS))
>  return 0;
>
> rmtp = (struct timespec *)restart->arg1;
> if (rmtp) {
>  time = ({ (ktime_t){ .tv64 = (t.timer.expires).tv64 - (t.timer.base->get_time()).tv64 }; });
>  if (time.tv64 <= 0)
>   return 0;
>  *rmtp = ns_to_timespec((time).tv64);
> }
>
> restart->fn = hrtimer_nanosleep_restart;
>
>
> return -516;
>}
>
>long hrtimer_nanosleep(struct timespec *rqtp, struct timespec *rmtp,
>         const enum hrtimer_mode mode, const clockid_t clockid)
>{
> struct restart_block *restart;
> struct hrtimer_sleeper t;
> ktime_t rem;
>
> hrtimer_init(&t.timer, clockid, mode);
> t.timer.expires = timespec_to_ktime(*rqtp);
> if (do_nanosleep(&t, mode))
>  return 0;
>
>
> if (mode == HRTIMER_MODE_ABS)
>  return -514;
>
> if (rmtp) {
>  rem = ({ (ktime_t){ .tv64 = (t.timer.expires).tv64 - (t.timer.base->get_time()).tv64 }; });
>  if (rem.tv64 <= 0)
>   return 0;
>  *rmtp = ns_to_timespec((rem).tv64);
> }
>
> restart = &current_thread_info()->restart_block;
> restart->fn = hrtimer_nanosleep_restart;
> restart->arg0 = (unsigned long) t.timer.base->index;
> restart->arg1 = (unsigned long) rmtp;
> restart->arg2 = t.timer.expires.tv64 & 0xFFFFFFFF;
> restart->arg3 = t.timer.expires.tv64 >> 32;
>
> return -516;
>}
>
> __attribute__((regparm(0))) long
>sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp)
>{
> struct timespec tu, rmt;
> int ret;
>
> if (copy_from_user(&tu, rqtp, sizeof(tu)))
>  return -14;
>
> if (!(((&tu)->tv_sec >= 0) && (((unsigned long) (&tu)->tv_nsec) < 1000000000L)))
>  return -22;
>
> ret = hrtimer_nanosleep(&tu, rmtp ? &rmt : ((void *)0), HRTIMER_MODE_REL,
>    1);
>
> if (ret && rmtp) {
>  if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
>   return -14;
> }
>
> return ret;
>}
>
>
>
>
>static void init_hrtimers_cpu(int cpu)
>{
> struct hrtimer_cpu_base *cpu_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (__per_cpu_offset[cpu])); }); }));
> int i;
>
> do { *(&cpu_base->lock) = (spinlock_t) { .raw_lock = { 1 }, }; } while (0);
> do { (void)(&cpu_base->lock_key); } while (0);
>
> for (i = 0; i < 2; i++)
>  cpu_base->clock_base[i].cpu_base = cpu_base;
>
> hrtimer_init_hres(cpu_base);
>}
>
>
>
>static void migrate_hrtimer_list(struct hrtimer_clock_base *old_base,
>    struct hrtimer_clock_base *new_base)
>{
> struct hrtimer *timer;
> struct rb_node *node;
>
> while ((node = rb_first(&old_base->active))) {
>  timer = ({ const typeof( ((struct hrtimer *)0)->node ) *__mptr = (node); (struct hrtimer *)( (char *)__mptr - __builtin_offsetof(struct hrtimer,node) );});
>  do { if (__builtin_expect(!!(hrtimer_callback_running(timer)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (1397), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
>  __remove_hrtimer(timer, old_base, 0x00, 0);
>  timer->base = new_base;
>
>
>
>  enqueue_hrtimer(timer, new_base, 1);
> }
>}
>
>static void migrate_hrtimers(int cpu)
>{
> struct hrtimer_cpu_base *old_base, *new_base;
> int i;
>
> do { if (__builtin_expect(!!((__builtin_constant_p(((cpu))) ? constant_test_bit((((cpu))),((cpu_online_map).bits)) : variable_test_bit((((cpu))),((cpu_online_map).bits)))), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b, %c0\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("kernel/hrtimer.c"), "i" (1412), "i" (sizeof(struct bug_entry))); for(;;) ; } while(0); } while(0);
> old_base = &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (__per_cpu_offset[cpu])); }); }));
> new_base = &(*({ extern int simple_identifier_hrtimer_bases(void); do { } while (0); &(*({ extern int simple_indentifier_hrtimer_bases(void); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"(&per_cpu__hrtimer_bases)); (typeof(&per_cpu__hrtimer_bases)) (__ptr + (({ typeof(per_cpu__this_cpu_off) ret__; switch (sizeof(per_cpu__this_cpu_off)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__this_cpu_off)); break; default: __bad_percpu_size(); } ret__; }))); }); })); }));
>
> tick_cancel_sched_timer(cpu);
>
> do { raw_local_irq_disable(); do { } while (0); } while (0);
> double_spin_lock(&new_base->lock, &old_base->lock,
>    (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; })) < cpu);
>
> for (i = 0; i < 2; i++) {
>  migrate_hrtimer_list(&old_base->clock_base[i],
>         &new_base->clock_base[i]);
> }
>
> double_spin_unlock(&new_base->lock, &old_base->lock,
>      (({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; })) < cpu);
> do { do { } while (0); raw_local_irq_enable(); } while (0);
> do { } while (0);
>}
>
>
>static int hrtimer_cpu_notify(struct notifier_block *self,
>     unsigned long action, void *hcpu)
>{
> unsigned int cpu = (long)hcpu;
>
> switch (action) {
>
> case 0x0003:
> case (0x0003 | 0x0010):
>  init_hrtimers_cpu(cpu);
>  break;
>
>
> case 0x0007:
> case (0x0007 | 0x0010):
>  clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DEAD, &cpu);
>  migrate_hrtimers(cpu);
>  break;
>
>
> default:
>  break;
> }
>
> return 0x0001;
>}
>
>static struct notifier_block hrtimers_nb = {
> .notifier_call = hrtimer_cpu_notify,
>};
>
>void __attribute__ ((__section__ (".init.text"))) hrtimers_init(void)
>{
> hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)0x0003,
>     (void *)(long)(({ typeof(per_cpu__cpu_number) ret__; switch (sizeof(per_cpu__cpu_number)) { case 1: asm("mov" "b ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 2: asm("mov" "w ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; case 4: asm("mov" "l ""%%fs:""%1,%0" : "=r" (ret__) : "m" (per_cpu__cpu_number)); break; default: __bad_percpu_size(); } ret__; })));
> register_cpu_notifier(&hrtimers_nb);
>
> open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq, ((void *)0));
>
>}

Actions: View

Attachments on bug 407281: 274801 | 274881 | 274891