4 # 1 "./include/linux/autoconf.h" 1
7 # 1 "include/asm/uaccess.h" 1
8 # 12 "include/asm/uaccess.h"
9 # 1 "include/linux/sched.h" 1
13 # 1 "include/linux/auxvec.h" 1
17 # 1 "include/asm/auxvec.h" 1
18 # 5 "include/linux/auxvec.h" 2
19 # 5 "include/linux/sched.h" 2
20 # 40 "include/linux/sched.h"
25 # 1 "include/asm/param.h" 1
26 # 45 "include/linux/sched.h" 2
28 # 1 "include/linux/capability.h" 1
29 # 16 "include/linux/capability.h"
30 # 1 "include/linux/types.h" 1
31 # 14 "include/linux/types.h"
32 # 1 "include/linux/posix_types.h" 1
36 # 1 "include/linux/stddef.h" 1
40 # 1 "include/linux/compiler.h" 1
41 # 42 "include/linux/compiler.h"
42 # 1 "include/linux/compiler-gcc4.h" 1
46 # 1 "include/linux/compiler-gcc.h" 1
47 # 5 "include/linux/compiler-gcc4.h" 2
48 # 43 "include/linux/compiler.h" 2
49 # 5 "include/linux/stddef.h" 2
50 # 15 "include/linux/stddef.h"
55 # 5 "include/linux/posix_types.h" 2
56 # 36 "include/linux/posix_types.h"
58 unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
62 typedef void (*__kernel_sighandler_t)(int);
65 typedef int __kernel_key_t;
66 typedef int __kernel_mqd_t;
68 # 1 "include/asm/posix_types.h" 1
69 # 10 "include/asm/posix_types.h"
70 typedef unsigned long __kernel_ino_t;
71 typedef unsigned short __kernel_mode_t;
72 typedef unsigned short __kernel_nlink_t;
73 typedef long __kernel_off_t;
74 typedef int __kernel_pid_t;
75 typedef unsigned int __kernel_ipc_pid_t;
76 typedef unsigned int __kernel_uid_t;
77 typedef unsigned int __kernel_gid_t;
78 typedef unsigned long __kernel_size_t;
79 typedef long __kernel_ssize_t;
80 typedef int __kernel_ptrdiff_t;
81 typedef long __kernel_time_t;
82 typedef long __kernel_suseconds_t;
83 typedef long __kernel_clock_t;
84 typedef int __kernel_timer_t;
85 typedef int __kernel_clockid_t;
86 typedef int __kernel_daddr_t;
87 typedef char *__kernel_caddr_t;
88 typedef unsigned short __kernel_uid16_t;
89 typedef unsigned short __kernel_gid16_t;
90 typedef unsigned int __kernel_uid32_t;
91 typedef unsigned int __kernel_gid32_t;
93 typedef unsigned short __kernel_old_uid_t;
94 typedef unsigned short __kernel_old_gid_t;
95 typedef unsigned short __kernel_old_dev_t;
98 typedef long long __kernel_loff_t;
108 # 48 "include/linux/posix_types.h" 2
109 # 15 "include/linux/types.h" 2
110 # 1 "include/asm/types.h" 1
111 # 13 "include/asm/types.h"
112 typedef unsigned short umode_t;
119 typedef __signed__ char __s8;
120 typedef unsigned char __u8;
122 typedef __signed__ short __s16;
123 typedef unsigned short __u16;
125 typedef __signed__ int __s32;
126 typedef unsigned int __u32;
130 typedef __signed__ long long __s64;
131 typedef unsigned long long __u64;
132 # 45 "include/asm/types.h"
133 typedef signed char s8;
134 typedef unsigned char u8;
136 typedef signed short s16;
137 typedef unsigned short u16;
139 typedef signed int s32;
140 typedef unsigned int u32;
142 typedef signed long long s64;
143 typedef unsigned long long u64;
147 typedef u32 dma_addr_t;
148 typedef u64 dma64_addr_t;
149 # 16 "include/linux/types.h" 2
153 typedef __u32 __kernel_dev_t;
155 typedef __kernel_fd_set fd_set;
156 typedef __kernel_dev_t dev_t;
157 typedef __kernel_ino_t ino_t;
158 typedef __kernel_mode_t mode_t;
159 typedef __kernel_nlink_t nlink_t;
160 typedef __kernel_off_t off_t;
161 typedef __kernel_pid_t pid_t;
162 typedef __kernel_daddr_t daddr_t;
163 typedef __kernel_key_t key_t;
164 typedef __kernel_suseconds_t suseconds_t;
165 typedef __kernel_timer_t timer_t;
166 typedef __kernel_clockid_t clockid_t;
167 typedef __kernel_mqd_t mqd_t;
172 typedef __kernel_uid32_t uid_t;
173 typedef __kernel_gid32_t gid_t;
174 typedef __kernel_uid16_t uid16_t;
175 typedef __kernel_gid16_t gid16_t;
179 typedef __kernel_old_uid_t old_uid_t;
180 typedef __kernel_old_gid_t old_gid_t;
181 # 58 "include/linux/types.h"
182 typedef __kernel_loff_t loff_t;
183 # 67 "include/linux/types.h"
184 typedef __kernel_size_t size_t;
189 typedef __kernel_ssize_t ssize_t;
194 typedef __kernel_ptrdiff_t ptrdiff_t;
199 typedef __kernel_time_t time_t;
204 typedef __kernel_clock_t clock_t;
209 typedef __kernel_caddr_t caddr_t;
213 typedef unsigned char u_char;
214 typedef unsigned short u_short;
215 typedef unsigned int u_int;
216 typedef unsigned long u_long;
219 typedef unsigned char unchar;
220 typedef unsigned short ushort;
221 typedef unsigned int uint;
222 typedef unsigned long ulong;
227 typedef __u8 u_int8_t;
229 typedef __u16 u_int16_t;
230 typedef __s16 int16_t;
231 typedef __u32 u_int32_t;
232 typedef __s32 int32_t;
236 typedef __u8 uint8_t;
237 typedef __u16 uint16_t;
238 typedef __u32 uint32_t;
241 typedef __u64 uint64_t;
242 typedef __u64 u_int64_t;
243 typedef __s64 int64_t;
244 # 143 "include/linux/types.h"
245 typedef unsigned long sector_t;
246 # 152 "include/linux/types.h"
247 typedef unsigned long blkcnt_t;
248 # 181 "include/linux/types.h"
249 typedef __u16 __le16;
250 typedef __u16 __be16;
251 typedef __u32 __le32;
252 typedef __u32 __be32;
254 typedef __u64 __le64;
255 typedef __u64 __be64;
257 typedef __u16 __sum16;
258 typedef __u32 __wsum;
261 typedef unsigned gfp_t;
266 typedef u32 resource_size_t;
272 __kernel_daddr_t f_tfree;
273 __kernel_ino_t f_tinode;
277 # 17 "include/linux/capability.h" 2
278 # 32 "include/linux/capability.h"
279 typedef struct __user_cap_header_struct {
282 } *cap_user_header_t;
284 typedef struct __user_cap_data_struct {
292 # 1 "include/linux/spinlock.h" 1
293 # 49 "include/linux/spinlock.h"
294 # 1 "include/linux/preempt.h" 1
295 # 9 "include/linux/preempt.h"
296 # 1 "include/linux/thread_info.h" 1
297 # 13 "include/linux/thread_info.h"
298 struct restart_block {
299 long (*fn)(struct restart_block *);
300 unsigned long arg0, arg1, arg2, arg3;
303 extern long do_no_restart_syscall(struct restart_block *parm);
305 # 1 "include/linux/bitops.h" 1
306 # 9 "include/linux/bitops.h"
307 # 1 "include/asm/bitops.h" 1
308 # 9 "include/asm/bitops.h"
309 # 1 "include/asm/byteorder.h" 1
310 # 9 "include/asm/byteorder.h"
311 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swahb32(__u32 xx)
314 __asm__("%1 = %0 >> 8 (V);\n\t"
315 "%0 = %0 << 8 (V);\n\t"
317 : "+d"(xx), "=&d"(tmp));
321 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 ___arch__swahw32(__u32 xx)
324 __asm__("%0 = PACK(%1.L, %1.H);\n\t": "=d"(rv): "d"(xx));
332 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 ___arch__swab16(__u16 xx)
335 __asm__("%0 <<= 8;\n %0.L = %0.L + %0.H (NS);\n": "+d"(xw));
338 # 46 "include/asm/byteorder.h"
339 # 1 "include/linux/byteorder/little_endian.h" 1
340 # 12 "include/linux/byteorder/little_endian.h"
341 # 1 "include/linux/byteorder/swab.h" 1
342 # 133 "include/linux/byteorder/swab.h"
343 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u16 __fswab16(__u16 x)
345 return ___arch__swab16(x);
347 static __inline__ __attribute__((always_inline)) __u16 __swab16p(const __u16 *x)
349 return ___arch__swab16(*(x));
351 static __inline__ __attribute__((always_inline)) void __swab16s(__u16 *addr)
353 do { *(addr) = ___arch__swab16(*((addr))); } while (0);
356 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u32 __fswab32(__u32 x)
358 return ___arch__swahb32(___arch__swahw32(x));
360 static __inline__ __attribute__((always_inline)) __u32 __swab32p(const __u32 *x)
362 return ___arch__swahb32(___arch__swahw32(*(x)));
364 static __inline__ __attribute__((always_inline)) void __swab32s(__u32 *addr)
366 do { *(addr) = ___arch__swahb32(___arch__swahw32(*((addr)))); } while (0);
370 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) __u64 __fswab64(__u64 x)
374 __u32 l = x & ((1ULL<<32)-1);
375 return (((__u64)(__builtin_constant_p((__u32)(l)) ? ({ __u32 __x = ((l)); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((l)))) << 32) | ((__u64)((__builtin_constant_p((__u32)(h)) ? ({ __u32 __x = ((h)); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((h)))));
380 static __inline__ __attribute__((always_inline)) __u64 __swab64p(const __u64 *x)
382 return ({ __u64 __tmp = (*(x)) ; ({ __u64 __x = (__tmp); ((__u64)( (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); }); });
384 static __inline__ __attribute__((always_inline)) void __swab64s(__u64 *addr)
386 do { *(addr) = ({ __u64 __tmp = (*((addr))) ; ({ __u64 __x = (__tmp); ((__u64)( (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) << 8) | (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >> 8) | (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); }); }); } while (0);
388 # 13 "include/linux/byteorder/little_endian.h" 2
389 # 43 "include/linux/byteorder/little_endian.h"
390 static inline __attribute__((always_inline)) __le64 __cpu_to_le64p(const __u64 *p)
394 static inline __attribute__((always_inline)) __u64 __le64_to_cpup(const __le64 *p)
398 static inline __attribute__((always_inline)) __le32 __cpu_to_le32p(const __u32 *p)
402 static inline __attribute__((always_inline)) __u32 __le32_to_cpup(const __le32 *p)
406 static inline __attribute__((always_inline)) __le16 __cpu_to_le16p(const __u16 *p)
410 static inline __attribute__((always_inline)) __u16 __le16_to_cpup(const __le16 *p)
414 static inline __attribute__((always_inline)) __be64 __cpu_to_be64p(const __u64 *p)
416 return ( __be64)__swab64p(p);
418 static inline __attribute__((always_inline)) __u64 __be64_to_cpup(const __be64 *p)
420 return __swab64p((__u64 *)p);
422 static inline __attribute__((always_inline)) __be32 __cpu_to_be32p(const __u32 *p)
424 return ( __be32)__swab32p(p);
426 static inline __attribute__((always_inline)) __u32 __be32_to_cpup(const __be32 *p)
428 return __swab32p((__u32 *)p);
430 static inline __attribute__((always_inline)) __be16 __cpu_to_be16p(const __u16 *p)
432 return ( __be16)__swab16p(p);
434 static inline __attribute__((always_inline)) __u16 __be16_to_cpup(const __be16 *p)
436 return __swab16p((__u16 *)p);
438 # 104 "include/linux/byteorder/little_endian.h"
439 # 1 "include/linux/byteorder/generic.h" 1
440 # 154 "include/linux/byteorder/generic.h"
441 extern __u32 ntohl(__be32);
442 extern __be32 htonl(__u32);
443 extern __u16 ntohs(__be16);
444 extern __be16 htons(__u16);
445 # 105 "include/linux/byteorder/little_endian.h" 2
446 # 47 "include/asm/byteorder.h" 2
447 # 10 "include/asm/bitops.h" 2
448 # 1 "include/asm/system.h" 1
449 # 37 "include/asm/system.h"
450 # 1 "include/linux/linkage.h" 1
454 # 1 "include/asm/linkage.h" 1
455 # 5 "include/linux/linkage.h" 2
456 # 38 "include/asm/system.h" 2
463 extern unsigned long irq_flags;
464 # 143 "include/asm/system.h"
465 struct __xchg_dummy {
466 unsigned long a[100];
470 static inline __attribute__((always_inline)) unsigned long __xchg(unsigned long x, volatile void *ptr,
473 unsigned long tmp = 0;
474 unsigned long flags = 0;
476 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
483 : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
489 : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
495 : "=&d" (tmp) : "d" (x), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
498 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
507 static inline __attribute__((always_inline)) unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
508 unsigned long new, int size)
510 unsigned long tmp = 0;
511 unsigned long flags = 0;
513 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
520 "IF !CC JUMP 1f;\n\t"
523 : "=&d" (tmp) : "d" (old), "d" (new), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
529 "IF !CC JUMP 1f;\n\t"
532 : "=&d" (tmp) : "d" (old), "d" (new), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
538 "IF !CC JUMP 1f;\n\t"
541 : "=&d" (tmp) : "d" (old), "d" (new), "m" (*((volatile struct __xchg_dummy *)(ptr))) : "memory");
544 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
547 # 237 "include/asm/system.h"
548 # 1 "include/asm/blackfin.h" 1
549 # 14 "include/asm/blackfin.h"
550 # 1 "include/asm/mach/blackfin.h" 1
551 # 36 "include/asm/mach/blackfin.h"
552 # 1 "include/asm/mach/bf533.h" 1
553 # 37 "include/asm/mach/blackfin.h" 2
554 # 1 "include/asm/mach/mem_map.h" 1
555 # 38 "include/asm/mach/blackfin.h" 2
556 # 1 "include/asm/mach/defBF532.h" 1
557 # 51 "include/asm/mach/defBF532.h"
558 # 1 "include/asm/mach-common/def_LPBlackfin.h" 1
559 # 34 "include/asm/mach-common/def_LPBlackfin.h"
560 # 1 "include/asm/mach/anomaly.h" 1
561 # 35 "include/asm/mach-common/def_LPBlackfin.h" 2
562 # 52 "include/asm/mach/defBF532.h" 2
563 # 39 "include/asm/mach/blackfin.h" 2
564 # 1 "include/asm/mach/anomaly.h" 1
565 # 40 "include/asm/mach/blackfin.h" 2
568 # 1 "include/asm/mach/cdefBF532.h" 1
569 # 42 "include/asm/mach/cdefBF532.h"
570 # 1 "include/asm/mach-common/cdef_LPBlackfin.h" 1
571 # 43 "include/asm/mach/cdefBF532.h" 2
573 # 1 "include/asm/system.h" 1
574 # 45 "include/asm/mach/cdefBF532.h" 2
575 # 58 "include/asm/mach/cdefBF532.h"
576 static __inline__ __attribute__((always_inline)) void bfin_write_VR_CTL(unsigned int val)
578 unsigned long flags, iwr;
581 iwr = ({ unsigned __v; __asm__ __volatile__ ("NOP;\n\t" "%0 = [%1];\n\t" : "=d"(__v) : "a"(0xFFC00124)); __v; });
583 ({ __asm__ __volatile__ ("NOP;\n\t" "[%0] = %1;\n\t" : : "a"(0xFFC00124) , "d"((1 << (0))) : "memory");});
585 ({ __asm__ __volatile__ ("NOP;\n\t" "w[%0] = %1;\n\t" : : "a"(0xFFC00008) , "d"(val) : "memory");});
586 __builtin_bfin_ssync();
588 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
590 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
591 ({ __asm__ __volatile__ ("NOP;\n\t" "[%0] = %1;\n\t" : : "a"(0xFFC00124) , "d"(iwr) : "memory");});
593 # 43 "include/asm/mach/blackfin.h" 2
594 # 15 "include/asm/blackfin.h" 2
595 # 1 "include/asm/bfin-global.h" 1
596 # 34 "include/asm/bfin-global.h"
597 # 1 "include/asm-generic/sections.h" 1
603 extern char _text[], _stext[], _etext[];
604 extern char _data[], _sdata[], _edata[];
605 extern char __bss_start[], __bss_stop[];
606 extern char __init_begin[], __init_end[];
607 extern char _sinittext[], _einittext[];
608 extern char _sextratext[] __attribute__((weak));
609 extern char _eextratext[] __attribute__((weak));
611 extern char __per_cpu_start[], __per_cpu_end[];
612 extern char __kprobes_text_start[], __kprobes_text_end[];
613 extern char __initdata_begin[], __initdata_end[];
614 extern char __start_rodata[], __end_rodata[];
615 # 35 "include/asm/bfin-global.h" 2
616 # 1 "include/asm/ptrace.h" 1
617 # 24 "include/asm/ptrace.h"
675 # 99 "include/asm/ptrace.h"
676 extern void show_regs(struct pt_regs *);
677 # 36 "include/asm/bfin-global.h" 2
678 # 1 "include/asm/user.h" 1
679 # 36 "include/asm/user.h"
680 struct user_bfinfp_struct {
686 struct user_regs_struct {
687 long r0, r1, r2, r3, r4, r5, r6, r7;
688 long p0, p1, p2, p3, p4, p5, usp, fp;
698 unsigned long orig_p0;
709 struct user_regs_struct regs;
712 unsigned long int u_tsize;
713 unsigned long int u_dsize;
714 unsigned long int u_ssize;
715 unsigned long start_code;
716 unsigned long start_stack;
722 struct user_regs_struct *u_ar0;
728 # 37 "include/asm/bfin-global.h" 2
729 # 48 "include/asm/bfin-global.h"
730 extern unsigned long get_cclk(void);
731 extern unsigned long get_sclk(void);
733 extern void dump_thread(struct pt_regs *regs, struct user *dump);
734 extern void dump_bfin_regs(struct pt_regs *fp, void *retaddr);
735 extern void dump_bfin_trace_buffer(void);
737 extern int init_arch_irq(void);
738 extern void bfin_reset(void);
739 extern void _cplb_hdr(void);
741 extern void bfin_icache_init(void);
742 extern void bfin_dcache_init(void);
743 extern int read_iloc(void);
744 extern int bfin_console_init(void);
745 extern void lower_to_irq14(void);
746 extern void init_dma(void);
747 extern void program_IAR(void);
748 extern void evt14_softirq(void);
749 extern void asm_do_IRQ(unsigned int irq, struct pt_regs *regs);
750 extern void bfin_gpio_interrupt_setup(int irq, int irq_pfx, int type);
752 extern void finish_atomic_sections (struct pt_regs *regs);
753 extern char fixed_code_start;
754 extern char fixed_code_end;
755 extern int atomic_xchg32(void);
756 extern int atomic_cas32(void);
757 extern int atomic_add32(void);
758 extern int atomic_sub32(void);
759 extern int atomic_ior32(void);
760 extern int atomic_and32(void);
761 extern int atomic_xor32(void);
762 extern void sigreturn_stub(void);
764 extern void *l1_data_A_sram_alloc(size_t);
765 extern void *l1_data_B_sram_alloc(size_t);
766 extern void *l1_inst_sram_alloc(size_t);
767 extern void *l1_data_sram_alloc(size_t);
768 extern void *l1_data_sram_zalloc(size_t);
769 extern int l1_data_A_sram_free(const void*);
770 extern int l1_data_B_sram_free(const void*);
771 extern int l1_inst_sram_free(const void*);
772 extern int l1_data_sram_free(const void*);
773 extern int sram_free(const void*);
779 extern void *sram_alloc_with_lsl(size_t, unsigned long);
780 extern int sram_free_with_lsl(const void*);
782 extern void led_on(int);
783 extern void led_off(int);
784 extern void led_toggle(int);
785 extern void led_disp_num(int);
786 extern void led_toggle_num(int);
787 extern void init_leds(void);
789 extern char *bfin_board_name __attribute__ ((weak));
790 extern unsigned long wall_jiffies;
791 extern unsigned long ipdt_table[];
792 extern unsigned long dpdt_table[];
793 extern unsigned long icplb_table[];
794 extern unsigned long dcplb_table[];
796 extern unsigned long ipdt_swapcount_table[];
797 extern unsigned long dpdt_swapcount_table[];
799 extern unsigned long table_start, table_end;
801 extern u16 _bfin_swrst;
802 extern struct file_operations dpmc_fops;
804 extern unsigned long _ramstart, _ramend, _rambase;
805 extern unsigned long memory_start, memory_end, physical_mem_end;
806 extern char _stext_l1[], _etext_l1[], _sdata_l1[], _edata_l1[], _sbss_l1[],
807 _ebss_l1[], _l1_lma_start[], _sdata_b_l1[], _ebss_b_l1[];
808 # 16 "include/asm/blackfin.h" 2
814 static inline __attribute__((always_inline)) void SSYNC (void)
817 __asm__ __volatile__ ("cli %0;\n\t"
823 # 55 "include/asm/blackfin.h"
824 static inline __attribute__((always_inline)) void CSYNC (void)
827 __asm__ __volatile__ ("cli %0;\n\t"
833 # 238 "include/asm/system.h" 2
835 struct task_struct *resume(struct task_struct *prev, struct task_struct *next);
836 # 11 "include/asm/bitops.h" 2
840 # 1 "include/asm-generic/bitops/ffs.h" 1
841 # 12 "include/asm-generic/bitops/ffs.h"
842 static inline __attribute__((always_inline)) int ffs(int x)
870 # 15 "include/asm/bitops.h" 2
871 # 1 "include/asm-generic/bitops/__ffs.h" 1
872 # 12 "include/asm-generic/bitops/__ffs.h"
873 static inline __attribute__((always_inline)) unsigned long __ffs(unsigned long word)
883 if ((word & 0xffff) == 0) {
887 if ((word & 0xff) == 0) {
891 if ((word & 0xf) == 0) {
895 if ((word & 0x3) == 0) {
899 if ((word & 0x1) == 0)
903 # 16 "include/asm/bitops.h" 2
904 # 1 "include/asm-generic/bitops/sched.h" 1
905 # 13 "include/asm-generic/bitops/sched.h"
906 static inline __attribute__((always_inline)) int sched_find_first_bit(const unsigned long *b)
915 if (__builtin_expect(!!(b[0]), 0))
917 if (__builtin_expect(!!(b[1]), 0))
918 return __ffs(b[1]) + 32;
919 if (__builtin_expect(!!(b[2]), 0))
920 return __ffs(b[2]) + 64;
922 return __ffs(b[3]) + 96;
923 return __ffs(b[4]) + 128;
928 # 17 "include/asm/bitops.h" 2
929 # 1 "include/asm-generic/bitops/ffz.h" 1
930 # 18 "include/asm/bitops.h" 2
932 static __inline__ __attribute__((always_inline)) void set_bit(int nr, volatile unsigned long *addr)
934 int *a = (int *)addr;
939 mask = 1 << (nr & 0x1f);
940 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
942 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
945 static __inline__ __attribute__((always_inline)) void __set_bit(int nr, volatile unsigned long *addr)
947 int *a = (int *)addr;
951 mask = 1 << (nr & 0x1f);
961 static __inline__ __attribute__((always_inline)) void clear_bit(int nr, volatile unsigned long *addr)
963 int *a = (int *)addr;
967 mask = 1 << (nr & 0x1f);
968 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
970 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
973 static __inline__ __attribute__((always_inline)) void __clear_bit(int nr, volatile unsigned long *addr)
975 int *a = (int *)addr;
979 mask = 1 << (nr & 0x1f);
983 static __inline__ __attribute__((always_inline)) void change_bit(int nr, volatile unsigned long *addr)
986 unsigned long *ADDR = (unsigned long *)addr;
989 mask = 1 << (nr & 31);
990 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
992 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
995 static __inline__ __attribute__((always_inline)) void __change_bit(int nr, volatile unsigned long *addr)
998 unsigned long *ADDR = (unsigned long *)addr;
1001 mask = 1 << (nr & 31);
1005 static __inline__ __attribute__((always_inline)) int test_and_set_bit(int nr, void *addr)
1008 volatile unsigned int *a = (volatile unsigned int *)addr;
1009 unsigned long flags;
1012 mask = 1 << (nr & 0x1f);
1013 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1014 retval = (mask & *a) != 0;
1016 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1021 static __inline__ __attribute__((always_inline)) int __test_and_set_bit(int nr, volatile unsigned long *addr)
1024 volatile unsigned int *a = (volatile unsigned int *)addr;
1027 mask = 1 << (nr & 0x1f);
1028 retval = (mask & *a) != 0;
1033 static __inline__ __attribute__((always_inline)) int test_and_clear_bit(int nr, volatile unsigned long *addr)
1036 volatile unsigned int *a = (volatile unsigned int *)addr;
1037 unsigned long flags;
1040 mask = 1 << (nr & 0x1f);
1041 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1042 retval = (mask & *a) != 0;
1044 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1049 static __inline__ __attribute__((always_inline)) int __test_and_clear_bit(int nr, volatile unsigned long *addr)
1052 volatile unsigned int *a = (volatile unsigned int *)addr;
1055 mask = 1 << (nr & 0x1f);
1056 retval = (mask & *a) != 0;
1061 static __inline__ __attribute__((always_inline)) int test_and_change_bit(int nr, volatile unsigned long *addr)
1064 volatile unsigned int *a = (volatile unsigned int *)addr;
1065 unsigned long flags;
1068 mask = 1 << (nr & 0x1f);
1069 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1070 retval = (mask & *a) != 0;
1072 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1076 static __inline__ __attribute__((always_inline)) int __test_and_change_bit(int nr,
1077 volatile unsigned long *addr)
1080 volatile unsigned int *a = (volatile unsigned int *)addr;
1083 mask = 1 << (nr & 0x1f);
1084 retval = (mask & *a) != 0;
1092 static __inline__ __attribute__((always_inline)) int __constant_test_bit(int nr, const void *addr)
1094 return ((1UL << (nr & 31)) &
1095 (((const volatile unsigned int *)addr)[nr >> 5])) != 0;
1098 static __inline__ __attribute__((always_inline)) int __test_bit(int nr, const void *addr)
1100 int *a = (int *)addr;
1104 mask = 1 << (nr & 0x1f);
1105 return ((mask & *a) != 0);
1113 # 1 "include/asm-generic/bitops/find.h" 1
1117 extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
1118 size, unsigned long offset);
1120 extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
1121 long size, unsigned long offset);
1122 # 201 "include/asm/bitops.h" 2
1123 # 1 "include/asm-generic/bitops/hweight.h" 1
1129 extern unsigned int hweight32(unsigned int w);
1130 extern unsigned int hweight16(unsigned int w);
1131 extern unsigned int hweight8(unsigned int w);
1132 extern unsigned long hweight64(__u64 w);
1133 # 202 "include/asm/bitops.h" 2
1135 # 1 "include/asm-generic/bitops/ext2-atomic.h" 1
1136 # 204 "include/asm/bitops.h" 2
1137 # 1 "include/asm-generic/bitops/ext2-non-atomic.h" 1
1141 # 1 "include/asm-generic/bitops/le.h" 1
1142 # 5 "include/asm-generic/bitops/ext2-non-atomic.h" 2
1143 # 205 "include/asm/bitops.h" 2
1145 # 1 "include/asm-generic/bitops/minix.h" 1
1146 # 207 "include/asm/bitops.h" 2
1150 # 1 "include/asm-generic/bitops/fls.h" 1
1151 # 12 "include/asm-generic/bitops/fls.h"
1152 static inline __attribute__((always_inline)) int fls(int x)
1158 if (!(x & 0xffff0000u)) {
1162 if (!(x & 0xff000000u)) {
1166 if (!(x & 0xf0000000u)) {
1170 if (!(x & 0xc0000000u)) {
1174 if (!(x & 0x80000000u)) {
1180 # 211 "include/asm/bitops.h" 2
1181 # 1 "include/asm-generic/bitops/fls64.h" 1
1187 static inline __attribute__((always_inline)) int fls64(__u64 x)
1194 # 212 "include/asm/bitops.h" 2
1195 # 10 "include/linux/bitops.h" 2
1197 static __inline__ __attribute__((always_inline)) int get_bitmask_order(unsigned int count)
1205 static __inline__ __attribute__((always_inline)) int get_count_order(unsigned int count)
1209 order = fls(count) - 1;
1210 if (count & (count - 1))
1215 static inline __attribute__((always_inline)) unsigned long hweight_long(unsigned long w)
1217 return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
1225 static inline __attribute__((always_inline)) __u32 rol32(__u32 word, unsigned int shift)
1227 return (word << shift) | (word >> (32 - shift));
1235 static inline __attribute__((always_inline)) __u32 ror32(__u32 word, unsigned int shift)
1237 return (word >> shift) | (word << (32 - shift));
1240 static inline __attribute__((always_inline)) unsigned fls_long(unsigned long l)
1246 # 21 "include/linux/thread_info.h" 2
1247 # 1 "include/asm/thread_info.h" 1
1248 # 30 "include/asm/thread_info.h"
1249 # 1 "include/asm/page.h" 1
1250 # 12 "include/asm/page.h"
1251 # 1 "include/asm/setup.h" 1
1252 # 13 "include/asm/page.h" 2
1253 # 28 "include/asm/page.h"
1258 unsigned long pmd[16];
1264 unsigned long pgprot;
1266 # 54 "include/asm/page.h"
1267 extern unsigned long memory_start;
1268 extern unsigned long memory_end;
1272 # 1 "include/asm/page_offset.h" 1
1273 # 60 "include/asm/page.h" 2
1274 # 1 "include/asm/io.h" 1
1275 # 23 "include/asm/io.h"
1276 static inline __attribute__((always_inline)) unsigned char readb(const volatile void *addr)
1281 __asm__ __volatile__ ("cli %1;\n\t"
1282 "NOP; NOP; SSYNC;\n\t"
1283 "%0 = b [%2] (z);\n\t"
1285 : "=d"(val), "=d"(tmp): "a"(addr)
1288 return (unsigned char) val;
1291 static inline __attribute__((always_inline)) unsigned short readw(const volatile void *addr)
1296 __asm__ __volatile__ ("cli %1;\n\t"
1297 "NOP; NOP; SSYNC;\n\t"
1298 "%0 = w [%2] (z);\n\t"
1300 : "=d"(val), "=d"(tmp): "a"(addr)
1303 return (unsigned short) val;
1306 static inline __attribute__((always_inline)) unsigned int readl(const volatile void *addr)
1311 __asm__ __volatile__ ("cli %1;\n\t"
1312 "NOP; NOP; SSYNC;\n\t"
1315 : "=d"(val), "=d"(tmp): "a"(addr)
1319 # 118 "include/asm/io.h"
1320 extern void outsb(void *port, const void *addr, unsigned short count);
1321 extern void outsw(void *port, const void *addr, unsigned short count);
1322 extern void outsl(void *port, const void *addr, unsigned short count);
1324 extern void insb(const void *port, void *addr, unsigned short count);
1325 extern void insw(const void *port, void *addr, unsigned short count);
1326 extern void insl(const void *port, void *addr, unsigned short count);
1328 extern void dma_outsb(void *port, const void *addr, unsigned short count);
1329 extern void dma_outsw(void *port, const void *addr, unsigned short count);
1330 extern void dma_outsl(void *port, const void *addr, unsigned short count);
1332 extern void dma_insb(const void *port, void *addr, unsigned short count);
1333 extern void dma_insw(const void *port, void *addr, unsigned short count);
1334 extern void dma_insl(const void *port, void *addr, unsigned short count);
1339 static inline __attribute__((always_inline)) void *__ioremap(unsigned long physaddr, unsigned long size,
1342 return (void *)physaddr;
1348 static inline __attribute__((always_inline)) void iounmap(void *addr)
1357 static inline __attribute__((always_inline)) void __iounmap(void *addr, unsigned long size)
1366 static inline __attribute__((always_inline)) void kernel_set_cachemode(void *addr, unsigned long size,
1371 static inline __attribute__((always_inline)) void *ioremap(unsigned long physaddr, unsigned long size)
1373 return __ioremap(physaddr, size, 1);
1375 static inline __attribute__((always_inline)) void *ioremap_nocache(unsigned long physaddr,
1378 return __ioremap(physaddr, size, 1);
1381 extern void blkfin_inv_cache_all(void);
1382 # 61 "include/asm/page.h" 2
1383 # 84 "include/asm/page.h"
1384 # 1 "include/asm-generic/page.h" 1
1385 # 10 "include/asm-generic/page.h"
1386 static __inline__ __attribute__((always_inline)) __attribute__((__const__)) int get_order(unsigned long size)
1390 size = (size - 1) >> (12 - 1);
1398 # 85 "include/asm/page.h" 2
1399 # 31 "include/asm/thread_info.h" 2
1400 # 1 "include/asm/entry.h" 1
1401 # 32 "include/asm/thread_info.h" 2
1402 # 1 "include/asm/l1layout.h" 1
1403 # 16 "include/asm/l1layout.h"
1404 struct l1_scratch_task_info
1413 # 33 "include/asm/thread_info.h" 2
1414 # 44 "include/asm/thread_info.h"
1415 typedef unsigned long mm_segment_t;
1422 struct thread_info {
1423 struct task_struct *task;
1424 struct exec_domain *exec_domain;
1425 unsigned long flags;
1428 mm_segment_t addr_limit;
1429 struct restart_block restart_block;
1430 struct l1_scratch_task_info l1_task_info;
1432 # 86 "include/asm/thread_info.h"
1433 static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
1434 __attribute__ ((__const__));
1439 static inline __attribute__((always_inline)) struct thread_info *current_thread_info(void)
1441 struct thread_info *ti;
1442 __asm__("%0 = sp;": "=&d"(ti):
1444 return (struct thread_info *)((long)ti & ~8191UL);
1446 # 22 "include/linux/thread_info.h" 2
1447 # 30 "include/linux/thread_info.h"
1448 static inline __attribute__((always_inline)) void set_ti_thread_flag(struct thread_info *ti, int flag)
1450 set_bit(flag,&ti->flags);
1453 static inline __attribute__((always_inline)) void clear_ti_thread_flag(struct thread_info *ti, int flag)
1455 clear_bit(flag,&ti->flags);
1458 static inline __attribute__((always_inline)) int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
1460 return test_and_set_bit(flag,&ti->flags);
1463 static inline __attribute__((always_inline)) int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
1465 return test_and_clear_bit(flag,&ti->flags);
1468 static inline __attribute__((always_inline)) int test_ti_thread_flag(struct thread_info *ti, int flag)
1470 return (__builtin_constant_p(flag) ? __constant_test_bit((flag),(&ti->flags)) : __test_bit((flag),(&ti->flags)));
1472 # 10 "include/linux/preempt.h" 2
1473 # 50 "include/linux/spinlock.h" 2
1477 # 1 "include/linux/kernel.h" 1
1478 # 10 "include/linux/kernel.h"
1479 # 1 "/usr/local/src/blackfin/toolchains/20070613/out-uclinux/lib/gcc/bfin-uclinux/4.1.2/include/stdarg.h" 1 3 4
1480 # 43 "/usr/local/src/blackfin/toolchains/20070613/out-uclinux/lib/gcc/bfin-uclinux/4.1.2/include/stdarg.h" 3 4
1481 typedef __builtin_va_list __gnuc_va_list;
1482 # 105 "/usr/local/src/blackfin/toolchains/20070613/out-uclinux/lib/gcc/bfin-uclinux/4.1.2/include/stdarg.h" 3 4
1483 typedef __gnuc_va_list va_list;
1484 # 11 "include/linux/kernel.h" 2
1490 # 1 "include/linux/log2.h" 1
1491 # 21 "include/linux/log2.h"
1492 extern __attribute__((const, noreturn))
1493 int ____ilog2_NaN(void);
1494 # 31 "include/linux/log2.h"
1495 static inline __attribute__((always_inline)) __attribute__((const))
1496 int __ilog2_u32(u32 n)
1503 static inline __attribute__((always_inline)) __attribute__((const))
1504 int __ilog2_u64(u64 n)
1506 return fls64(n) - 1;
1515 static inline __attribute__((always_inline)) __attribute__((const))
1516 bool is_power_of_2(unsigned long n)
1518 return (n != 0 && ((n & (n - 1)) == 0));
1524 static inline __attribute__((always_inline)) __attribute__((const))
1525 unsigned long __roundup_pow_of_two(unsigned long n)
1527 return 1UL << fls_long(n - 1);
1529 # 17 "include/linux/kernel.h" 2
1531 # 1 "include/asm/bug.h" 1
1534 # 1 "include/asm-generic/bug.h" 1
1535 # 4 "include/asm/bug.h" 2
1536 # 19 "include/linux/kernel.h" 2
1538 extern const char linux_banner[];
1539 extern const char linux_proc_banner[];
1540 # 52 "include/linux/kernel.h"
1541 extern int console_printk[];
1551 # 74 "include/linux/kernel.h"
1552 extern int cond_resched(void);
1553 # 95 "include/linux/kernel.h"
1554 extern struct atomic_notifier_head panic_notifier_list;
1555 extern long (*panic_blink)(long time);
1556 void panic(const char * fmt, ...)
1557 __attribute__ ((noreturn, format (printf, 1, 2)));
1558 extern void oops_enter(void);
1559 extern void oops_exit(void);
1560 extern int oops_may_print(void);
1561 void do_exit(long error_code)
1562 __attribute__((noreturn));
1563 void complete_and_exit(struct completion *, long)
1564 __attribute__((noreturn));
1565 extern unsigned long simple_strtoul(const char *,char **,unsigned int);
1566 extern long simple_strtol(const char *,char **,unsigned int);
1567 extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
1568 extern long long simple_strtoll(const char *,char **,unsigned int);
1569 extern int sprintf(char * buf, const char * fmt, ...)
1570 __attribute__ ((format (printf, 2, 3)));
1571 extern int vsprintf(char *buf, const char *, va_list)
1572 __attribute__ ((format (printf, 2, 0)));
1573 extern int snprintf(char * buf, size_t size, const char * fmt, ...)
1574 __attribute__ ((format (printf, 3, 4)));
1575 extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1576 __attribute__ ((format (printf, 3, 0)));
1577 extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
1578 __attribute__ ((format (printf, 3, 4)));
1579 extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1580 __attribute__ ((format (printf, 3, 0)));
1581 extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
1582 __attribute__ ((format (printf, 2, 3)));
1584 extern int sscanf(const char *, const char *, ...)
1585 __attribute__ ((format (scanf, 2, 3)));
1586 extern int vsscanf(const char *, const char *, va_list)
1587 __attribute__ ((format (scanf, 2, 0)));
1589 extern int get_option(char **str, int *pint);
1590 extern char *get_options(const char *str, int nints, int *ints);
1591 extern unsigned long long memparse(char *ptr, char **retptr);
1593 extern int core_kernel_text(unsigned long addr);
1594 extern int __kernel_text_address(unsigned long addr);
1595 extern int kernel_text_address(unsigned long addr);
1597 extern struct pid *session_of_pgrp(struct pid *pgrp);
1599 extern void dump_thread(struct pt_regs *regs, struct user *dump);
1602 int vprintk(const char *fmt, va_list args)
1603 __attribute__ ((format (printf, 1, 0)));
1604 int printk(const char * fmt, ...)
1605 __attribute__ ((format (printf, 1, 2)));
1606 # 156 "include/linux/kernel.h"
1607 unsigned long int_sqrt(unsigned long);
1609 extern int printk_ratelimit(void);
1610 extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);
1611 extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
1612 unsigned int interval_msec);
1614 static inline __attribute__((always_inline)) void console_silent(void)
1616 (console_printk[0]) = 0;
1619 static inline __attribute__((always_inline)) void console_verbose(void)
1621 if ((console_printk[0]))
1622 (console_printk[0]) = 15;
1625 extern void bust_spinlocks(int yes);
1626 extern void wake_up_klogd(void);
1627 extern int oops_in_progress;
1628 extern int panic_timeout;
1629 extern int panic_on_oops;
1630 extern int panic_on_unrecovered_nmi;
1632 extern const char *print_tainted(void);
1633 extern void add_taint(unsigned);
1636 extern enum system_states {
1642 SYSTEM_SUSPEND_DISK,
1644 # 202 "include/linux/kernel.h"
1645 extern void dump_stack(void);
1652 static inline __attribute__((always_inline)) int __attribute__ ((format (printf, 1, 2))) pr_debug(const char * fmt, ...)
1656 # 313 "include/linux/kernel.h"
1658 extern int do_sysinfo(struct sysinfo *info);
1665 unsigned long loads[3];
1666 unsigned long totalram;
1667 unsigned long freeram;
1668 unsigned long sharedram;
1669 unsigned long bufferram;
1670 unsigned long totalswap;
1671 unsigned long freeswap;
1672 unsigned short procs;
1674 unsigned long totalhigh;
1675 unsigned long freehigh;
1676 unsigned int mem_unit;
1677 char _f[20-2*sizeof(long)-sizeof(int)];
1679 # 54 "include/linux/spinlock.h" 2
1680 # 1 "include/linux/stringify.h" 1
1681 # 55 "include/linux/spinlock.h" 2
1682 # 1 "include/linux/bottom_half.h" 1
1686 extern void local_bh_disable(void);
1687 extern void __local_bh_enable(void);
1688 extern void _local_bh_enable(void);
1689 extern void local_bh_enable(void);
1690 extern void local_bh_enable_ip(unsigned long ip);
1691 # 56 "include/linux/spinlock.h" 2
1692 # 79 "include/linux/spinlock.h"
1693 # 1 "include/linux/spinlock_types.h" 1
1694 # 12 "include/linux/spinlock_types.h"
1695 # 1 "include/linux/lockdep.h" 1
1696 # 11 "include/linux/lockdep.h"
1698 # 252 "include/linux/lockdep.h"
1699 static inline __attribute__((always_inline)) void lockdep_off(void)
1703 static inline __attribute__((always_inline)) void lockdep_on(void)
1706 # 278 "include/linux/lockdep.h"
1707 struct lock_class_key { };
1708 # 287 "include/linux/lockdep.h"
1709 static inline __attribute__((always_inline)) void early_init_irq_lock_class(void)
1719 static inline __attribute__((always_inline)) void early_boot_irqs_off(void)
1722 static inline __attribute__((always_inline)) void early_boot_irqs_on(void)
1725 static inline __attribute__((always_inline)) void print_irqtrace_events(struct task_struct *curr)
1728 # 13 "include/linux/spinlock_types.h" 2
1733 # 1 "include/linux/spinlock_types_up.h" 1
1734 # 29 "include/linux/spinlock_types_up.h"
1735 typedef struct { } raw_spinlock_t;
1747 # 18 "include/linux/spinlock_types.h" 2
1751 raw_spinlock_t raw_lock;
1752 # 32 "include/linux/spinlock_types.h"
1758 raw_rwlock_t raw_lock;
1759 # 48 "include/linux/spinlock_types.h"
1761 # 80 "include/linux/spinlock.h" 2
1763 extern int __attribute__((section(".spinlock.text"))) generic__raw_read_trylock(raw_rwlock_t *lock);
1771 # 1 "include/linux/spinlock_up.h" 1
1772 # 90 "include/linux/spinlock.h" 2
1773 # 135 "include/linux/spinlock.h"
1774 # 1 "include/linux/spinlock_api_up.h" 1
1775 # 136 "include/linux/spinlock.h" 2
1776 # 289 "include/linux/spinlock.h"
1777 static inline __attribute__((always_inline)) void double_spin_lock(spinlock_t *l1, spinlock_t *l2,
1783 do { do { } while (0); (void)0; (void)(l1); } while (0);
1784 do { do { } while (0); (void)0; (void)(l2); } while (0);
1786 do { do { } while (0); (void)0; (void)(l2); } while (0);
1787 do { do { } while (0); (void)0; (void)(l1); } while (0);
1796 static inline __attribute__((always_inline)) void double_spin_unlock(spinlock_t *l1, spinlock_t *l2,
1797 bool l1_taken_first)
1801 if (l1_taken_first) {
1802 do { do { } while (0); (void)0; (void)(l2); } while (0);
1803 do { do { } while (0); (void)0; (void)(l1); } while (0);
1805 do { do { } while (0); (void)0; (void)(l1); } while (0);
1806 do { do { } while (0); (void)0; (void)(l2); } while (0);
1814 # 1 "include/asm/atomic.h" 1
1815 # 16 "include/asm/atomic.h"
1824 static __inline__ __attribute__((always_inline)) void atomic_add(int i, atomic_t * v)
1828 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1830 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1833 static __inline__ __attribute__((always_inline)) void atomic_sub(int i, atomic_t * v)
1837 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1839 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1843 static inline __attribute__((always_inline)) int atomic_add_return(int i, atomic_t * v)
1848 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1850 __temp = v->counter;
1851 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1858 static inline __attribute__((always_inline)) int atomic_sub_return(int i, atomic_t * v)
1863 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1865 __temp = v->counter;
1866 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1871 static __inline__ __attribute__((always_inline)) void atomic_inc(volatile atomic_t * v)
1875 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1877 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1879 # 93 "include/asm/atomic.h"
1880 static __inline__ __attribute__((always_inline)) void atomic_dec(volatile atomic_t * v)
1884 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1886 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1889 static __inline__ __attribute__((always_inline)) void atomic_clear_mask(unsigned int mask, atomic_t * v)
1893 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1894 v->counter &= ~mask;
1895 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1898 static __inline__ __attribute__((always_inline)) void atomic_set_mask(unsigned int mask, atomic_t * v)
1902 do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0);
1904 do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0);
1906 # 142 "include/asm/atomic.h"
1907 # 1 "include/asm-generic/atomic.h" 1
1908 # 71 "include/asm-generic/atomic.h"
1909 typedef atomic_t atomic_long_t;
1912 static inline __attribute__((always_inline)) long atomic_long_read(atomic_long_t *l)
1914 atomic_t *v = (atomic_t *)l;
1916 return (long)((v)->counter);
1919 static inline __attribute__((always_inline)) void atomic_long_set(atomic_long_t *l, long i)
1921 atomic_t *v = (atomic_t *)l;
1923 (((v)->counter) = i);
1926 static inline __attribute__((always_inline)) void atomic_long_inc(atomic_long_t *l)
1928 atomic_t *v = (atomic_t *)l;
1933 static inline __attribute__((always_inline)) void atomic_long_dec(atomic_long_t *l)
1935 atomic_t *v = (atomic_t *)l;
1940 static inline __attribute__((always_inline)) void atomic_long_add(long i, atomic_long_t *l)
1942 atomic_t *v = (atomic_t *)l;
1947 static inline __attribute__((always_inline)) void atomic_long_sub(long i, atomic_long_t *l)
1949 atomic_t *v = (atomic_t *)l;
1953 # 143 "include/asm/atomic.h" 2
1954 # 327 "include/linux/spinlock.h" 2
1960 extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
1961 # 46 "include/linux/capability.h" 2
1962 # 1 "include/asm/current.h" 1
1963 # 13 "include/asm/current.h"
1966 static inline __attribute__((always_inline)) struct task_struct *get_current(void) __attribute__ ((__const__));
1967 static inline __attribute__((always_inline)) struct task_struct *get_current(void)
1969 return (current_thread_info()->task);
1971 # 47 "include/linux/capability.h" 2
1972 # 58 "include/linux/capability.h"
1973 typedef __u32 kernel_cap_t;
1974 # 295 "include/linux/capability.h"
1975 extern kernel_cap_t cap_bset;
1976 # 323 "include/linux/capability.h"
1977 static inline __attribute__((always_inline)) kernel_cap_t cap_combine(kernel_cap_t a, kernel_cap_t b)
1984 static inline __attribute__((always_inline)) kernel_cap_t cap_intersect(kernel_cap_t a, kernel_cap_t b)
1991 static inline __attribute__((always_inline)) kernel_cap_t cap_drop(kernel_cap_t a, kernel_cap_t drop)
1994 (dest) = (a) & ~(drop);
1998 static inline __attribute__((always_inline)) kernel_cap_t cap_invert(kernel_cap_t c)
2004 # 360 "include/linux/capability.h"
2005 int capable(int cap);
2006 int __capable(struct task_struct *t, int cap);
2007 # 47 "include/linux/sched.h" 2
2008 # 1 "include/linux/threads.h" 1
2009 # 48 "include/linux/sched.h" 2
2012 # 1 "include/linux/timex.h" 1
2013 # 57 "include/linux/timex.h"
2014 # 1 "include/linux/time.h" 1
2021 # 1 "include/linux/seqlock.h" 1
2022 # 32 "include/linux/seqlock.h"
2027 # 60 "include/linux/seqlock.h"
2028 static inline __attribute__((always_inline)) void write_seqlock(seqlock_t *sl)
2030 do { do { } while (0); (void)0; (void)(&sl->lock); } while (0);
2032 __asm__ __volatile__("": : :"memory");
2035 static inline __attribute__((always_inline)) void write_sequnlock(seqlock_t *sl)
2037 __asm__ __volatile__("": : :"memory");
2039 do { do { } while (0); (void)0; (void)(&sl->lock); } while (0);
2042 static inline __attribute__((always_inline)) int write_tryseqlock(seqlock_t *sl)
2044 int ret = (({ do { do { } while (0); (void)0; (void)(&sl->lock); } while (0); 1; }));
2048 __asm__ __volatile__("": : :"memory");
2054 static inline __attribute__((always_inline)) __attribute__((always_inline)) unsigned read_seqbegin(const seqlock_t *sl)
2056 unsigned ret = sl->sequence;
2057 __asm__ __volatile__("": : :"memory");
2060 # 101 "include/linux/seqlock.h"
2061 static inline __attribute__((always_inline)) __attribute__((always_inline)) int read_seqretry(const seqlock_t *sl, unsigned iv)
2063 __asm__ __volatile__("": : :"memory");
2064 return (iv & 1) | (sl->sequence ^ iv);
2066 # 115 "include/linux/seqlock.h"
2067 typedef struct seqcount {
2075 static inline __attribute__((always_inline)) unsigned read_seqcount_begin(const seqcount_t *s)
2077 unsigned ret = s->sequence;
2078 __asm__ __volatile__("": : :"memory");
2087 static inline __attribute__((always_inline)) int read_seqcount_retry(const seqcount_t *s, unsigned iv)
2089 __asm__ __volatile__("": : :"memory");
2090 return (iv & 1) | (s->sequence ^ iv);
2098 static inline __attribute__((always_inline)) void write_seqcount_begin(seqcount_t *s)
2101 __asm__ __volatile__("": : :"memory");
2104 static inline __attribute__((always_inline)) void write_seqcount_end(seqcount_t *s)
2106 __asm__ __volatile__("": : :"memory");
2109 # 8 "include/linux/time.h" 2
2122 suseconds_t tv_usec;
2129 # 39 "include/linux/time.h"
2130 static inline __attribute__((always_inline)) int timespec_equal(struct timespec *a, struct timespec *b)
2132 return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
2140 static inline __attribute__((always_inline)) int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
2142 if (lhs->tv_sec < rhs->tv_sec)
2144 if (lhs->tv_sec > rhs->tv_sec)
2146 return lhs->tv_nsec - rhs->tv_nsec;
2149 static inline __attribute__((always_inline)) int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
2151 if (lhs->tv_sec < rhs->tv_sec)
2153 if (lhs->tv_sec > rhs->tv_sec)
2155 return lhs->tv_usec - rhs->tv_usec;
2158 extern unsigned long mktime(const unsigned int year, const unsigned int mon,
2159 const unsigned int day, const unsigned int hour,
2160 const unsigned int min, const unsigned int sec);
2162 extern void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec);
2167 static inline __attribute__((always_inline)) struct timespec timespec_sub(struct timespec lhs,
2168 struct timespec rhs)
2170 struct timespec ts_delta;
2171 set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
2172 lhs.tv_nsec - rhs.tv_nsec);
2182 extern struct timespec xtime;
2183 extern struct timespec wall_to_monotonic;
2184 extern seqlock_t xtime_lock __attribute__((weak));
2186 extern unsigned long read_persistent_clock(void);
2187 void timekeeping_init(void);
2189 static inline __attribute__((always_inline)) unsigned long get_seconds(void)
2191 return xtime.tv_sec;
2194 struct timespec current_kernel_time(void);
2199 extern void do_gettimeofday(struct timeval *tv);
2200 extern int do_settimeofday(struct timespec *tv);
2201 extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
2203 extern long do_utimes(int dfd, char *filename, struct timeval *times);
2205 extern int do_setitimer(int which, struct itimerval *value,
2206 struct itimerval *ovalue);
2207 extern unsigned int alarm_setitimer(unsigned int seconds);
2208 extern int do_getitimer(int which, struct itimerval *value);
2209 extern void getnstimeofday(struct timespec *tv);
2211 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
2212 extern int timekeeping_is_continuous(void);
2213 # 130 "include/linux/time.h"
2214 static inline __attribute__((always_inline)) s64 timespec_to_ns(const struct timespec *ts)
2216 return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;
2218 # 142 "include/linux/time.h"
2219 static inline __attribute__((always_inline)) s64 timeval_to_ns(const struct timeval *tv)
2221 return ((s64) tv->tv_sec * 1000000000L) +
2222 tv->tv_usec * 1000L;
2231 extern struct timespec ns_to_timespec(const s64 nsec);
2239 extern struct timeval ns_to_timeval(const s64 nsec);
2246 static inline __attribute__((always_inline)) void timespec_add_ns(struct timespec *a, u64 ns)
2249 while(__builtin_expect(!!(ns >= 1000000000L), 0)) {
2255 # 196 "include/linux/time.h"
2257 struct timespec it_interval;
2258 struct timespec it_value;
2262 struct timeval it_interval;
2263 struct timeval it_value;
2265 # 58 "include/linux/timex.h" 2
2266 # 100 "include/linux/timex.h"
2279 struct timeval time;
2291 int :32; int :32; int :32; int :32;
2292 int :32; int :32; int :32; int :32;
2293 int :32; int :32; int :32; int :32;
2295 # 187 "include/linux/timex.h"
2296 # 1 "include/asm/timex.h" 1
2297 # 11 "include/asm/timex.h"
2298 typedef unsigned long cycles_t;
2300 static inline __attribute__((always_inline)) cycles_t get_cycles(void)
2304 # 188 "include/linux/timex.h" 2
2311 extern unsigned long tick_usec;
2312 extern unsigned long tick_nsec;
2318 extern int time_status;
2319 extern long time_maxerror;
2320 extern long time_esterror;
2322 extern long time_freq;
2324 extern long time_adjust;
2326 extern void ntp_clear(void);
2332 static inline __attribute__((always_inline)) int ntp_synced(void)
2334 return !(time_status & 0x0040);
2336 # 277 "include/linux/timex.h"
2337 static inline __attribute__((always_inline)) void time_interpolator_reset(void)
2341 static inline __attribute__((always_inline)) void time_interpolator_update(long delta_nsec)
2344 # 297 "include/linux/timex.h"
2345 extern u64 current_tick_length(void);
2347 extern void second_overflow(void);
2348 extern void update_ntp_one_tick(void);
2349 extern int do_adjtimex(struct timex *);
2350 # 51 "include/linux/sched.h" 2
2351 # 1 "include/linux/jiffies.h" 1
2355 # 1 "include/linux/calc64.h" 1
2360 # 1 "include/asm/div64.h" 1
2361 # 1 "include/asm-generic/div64.h" 1
2362 # 35 "include/asm-generic/div64.h"
2363 extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
2364 # 1 "include/asm/div64.h" 2
2365 # 6 "include/linux/calc64.h" 2
2366 # 20 "include/linux/calc64.h"
2367 static inline __attribute__((always_inline)) unsigned long do_div_llr(const long long dividend,
2368 const long divisor, long *remainder)
2370 u64 result = dividend;
2372 *(remainder) = ({ uint32_t __base = (divisor); uint32_t __rem; (void)(((typeof((result)) *)0) == ((uint64_t *)0)); if (__builtin_expect(!!(((result) >> 32) == 0), 1)) { __rem = (uint32_t)(result) % __base; (result) = (uint32_t)(result) / __base; } else __rem = __div64_32(&(result), __base); __rem; });
2373 return (unsigned long) result;
2382 static inline __attribute__((always_inline)) long div_long_long_rem_signed(const long long dividend,
2383 const long divisor, long *remainder)
2387 if (__builtin_expect(!!(dividend < 0), 0)) {
2388 res = -do_div_llr((-dividend), divisor, remainder);
2389 *remainder = -(*remainder);
2391 res = do_div_llr((dividend), divisor, remainder);
2395 # 5 "include/linux/jiffies.h" 2
2396 # 81 "include/linux/jiffies.h"
2397 extern u64 __attribute__((section(".data"))) jiffies_64;
2398 extern unsigned long volatile __attribute__((section(".data"))) jiffies;
2401 u64 get_jiffies_64(void);
2402 # 264 "include/linux/jiffies.h"
2403 extern unsigned int jiffies_to_msecs(const unsigned long j);
2404 extern unsigned int jiffies_to_usecs(const unsigned long j);
2405 extern unsigned long msecs_to_jiffies(const unsigned int m);
2406 extern unsigned long usecs_to_jiffies(const unsigned int u);
2407 extern unsigned long timespec_to_jiffies(const struct timespec *value);
2408 extern void jiffies_to_timespec(const unsigned long jiffies,
2409 struct timespec *value);
2410 extern unsigned long timeval_to_jiffies(const struct timeval *value);
2411 extern void jiffies_to_timeval(const unsigned long jiffies,
2412 struct timeval *value);
2413 extern clock_t jiffies_to_clock_t(long x);
2414 extern unsigned long clock_t_to_jiffies(unsigned long x);
2415 extern u64 jiffies_64_to_clock_t(u64 x);
2416 extern u64 nsec_to_clock_t(u64 x);
2417 # 52 "include/linux/sched.h" 2
2418 # 1 "include/linux/rbtree.h" 1
2419 # 100 "include/linux/rbtree.h"
2422 unsigned long rb_parent_color;
2425 struct rb_node *rb_right;
2426 struct rb_node *rb_left;
2427 } __attribute__((aligned(sizeof(long))));
2432 struct rb_node *rb_node;
2434 # 123 "include/linux/rbtree.h"
2435 static inline __attribute__((always_inline)) void rb_set_parent(struct rb_node *rb, struct rb_node *p)
2437 rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
2439 static inline __attribute__((always_inline)) void rb_set_color(struct rb_node *rb, int color)
2441 rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
2443 # 139 "include/linux/rbtree.h"
2444 extern void rb_insert_color(struct rb_node *, struct rb_root *);
2445 extern void rb_erase(struct rb_node *, struct rb_root *);
2448 extern struct rb_node *rb_next(struct rb_node *);
2449 extern struct rb_node *rb_prev(struct rb_node *);
2450 extern struct rb_node *rb_first(struct rb_root *);
2451 extern struct rb_node *rb_last(struct rb_root *);
2454 extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
2455 struct rb_root *root);
2457 static inline __attribute__((always_inline)) void rb_link_node(struct rb_node * node, struct rb_node * parent,
2458 struct rb_node ** rb_link)
2460 node->rb_parent_color = (unsigned long )parent;
2461 node->rb_left = node->rb_right = ((void *)0);
2465 # 53 "include/linux/sched.h" 2
2467 # 1 "include/linux/cpumask.h" 1
2468 # 86 "include/linux/cpumask.h"
2469 # 1 "include/linux/bitmap.h" 1
2477 # 1 "include/linux/string.h" 1
2478 # 16 "include/linux/string.h"
2479 extern char *strndup_user(const char *, long);
2484 # 1 "include/asm/string.h" 1
2491 extern inline __attribute__((always_inline)) char *strcpy(char *dest, const char *src)
2496 __asm__ __volatile__
2497 ("1:\t%2 = B [%1++] (Z);\n\t"
2498 "B [%0++] = %2;\n\t"
2500 "if cc jump 1b (bp);\n"
2501 : "+&a" (dest), "+&a" (src), "=&d" (temp)
2507 extern inline __attribute__((always_inline)) char *strncpy(char *dest, const char *src, size_t n)
2515 __asm__ __volatile__
2516 ("1:\t%3 = B [%1++] (Z);\n\t"
2517 "B [%0++] = %3;\n\t"
2519 "if ! cc jump 2f;\n\t"
2522 "if ! cc jump 1b (bp);\n"
2524 : "+&a" (dest), "+&a" (src), "+&da" (n), "=&d" (temp)
2530 extern inline __attribute__((always_inline)) int strcmp(const char *cs, const char *ct)
2532 char __res1, __res2;
2535 ("1:\t%2 = B[%0++] (Z);\n\t"
2536 "%3 = B[%1++] (Z);\n\t"
2537 "CC = %2 == %3;\n\t"
2538 "if ! cc jump 2f;\n\t"
2540 "if cc jump 1b (bp);\n\t"
2542 "2:\t%2 = %2 - %3;\n"
2544 : "+&a" (cs), "+&a" (ct), "=&d" (__res1), "=&d" (__res2)
2551 extern inline __attribute__((always_inline)) int strncmp(const char *cs, const char *ct, size_t count)
2553 char __res1, __res2;
2558 ("1:\t%3 = B[%0++] (Z);\n\t"
2559 "%4 = B[%1++] (Z);\n\t"
2560 "CC = %3 == %4;\n\t"
2561 "if ! cc jump 3f;\n\t"
2563 "if ! cc jump 4f;\n\t"
2566 "if ! cc jump 1b;\n"
2569 "3:\t%3 = %3 - %4;\n"
2571 : "+&a" (cs), "+&a" (ct), "+&da" (count), "=&d" (__res1), "=&d" (__res2)
2577 extern void *memset(void *s, int c, size_t count);
2579 extern void *memcpy(void *d, const void *s, size_t count);
2581 extern int memcmp(const void *, const void *, __kernel_size_t);
2583 extern void *memchr(const void *s, int c, size_t n);
2585 extern void *memmove(void *dest, const void *src, size_t count);
2586 # 22 "include/linux/string.h" 2
2587 # 30 "include/linux/string.h"
2588 size_t strlcpy(char *, const char *, size_t);
2591 extern char * strcat(char *, const char *);
2594 extern char * strncat(char *, const char *, __kernel_size_t);
2597 extern size_t strlcat(char *, const char *, __kernel_size_t);
2598 # 48 "include/linux/string.h"
2599 extern int strnicmp(const char *, const char *, __kernel_size_t);
2602 extern char * strchr(const char *,int);
2605 extern char * strnchr(const char *, size_t, int);
2608 extern char * strrchr(const char *,int);
2610 extern char * strstrip(char *);
2612 extern char * strstr(const char *,const char *);
2615 extern __kernel_size_t strlen(const char *);
2618 extern __kernel_size_t strnlen(const char *,__kernel_size_t);
2621 extern char * strpbrk(const char *,const char *);
2624 extern char * strsep(char **,const char *);
2627 extern __kernel_size_t strspn(const char *,const char *);
2630 extern __kernel_size_t strcspn(const char *,const char *);
2631 # 92 "include/linux/string.h"
2632 extern void * memscan(void *,int,__kernel_size_t);
2633 # 101 "include/linux/string.h"
2634 extern char *kstrdup(const char *s, gfp_t gfp);
2635 extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
2636 # 9 "include/linux/bitmap.h" 2
2637 # 84 "include/linux/bitmap.h"
2638 extern int __bitmap_empty(const unsigned long *bitmap, int bits);
2639 extern int __bitmap_full(const unsigned long *bitmap, int bits);
2640 extern int __bitmap_equal(const unsigned long *bitmap1,
2641 const unsigned long *bitmap2, int bits);
2642 extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
2644 extern void __bitmap_shift_right(unsigned long *dst,
2645 const unsigned long *src, int shift, int bits);
2646 extern void __bitmap_shift_left(unsigned long *dst,
2647 const unsigned long *src, int shift, int bits);
2648 extern void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
2649 const unsigned long *bitmap2, int bits);
2650 extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
2651 const unsigned long *bitmap2, int bits);
2652 extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
2653 const unsigned long *bitmap2, int bits);
2654 extern void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
2655 const unsigned long *bitmap2, int bits);
2656 extern int __bitmap_intersects(const unsigned long *bitmap1,
2657 const unsigned long *bitmap2, int bits);
2658 extern int __bitmap_subset(const unsigned long *bitmap1,
2659 const unsigned long *bitmap2, int bits);
2660 extern int __bitmap_weight(const unsigned long *bitmap, int bits);
2662 extern int bitmap_scnprintf(char *buf, unsigned int len,
2663 const unsigned long *src, int nbits);
2664 extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
2665 unsigned long *dst, int nbits);
2666 extern int bitmap_parse_user(const char *ubuf, unsigned int ulen,
2667 unsigned long *dst, int nbits);
2668 extern int bitmap_scnlistprintf(char *buf, unsigned int len,
2669 const unsigned long *src, int nbits);
2670 extern int bitmap_parselist(const char *buf, unsigned long *maskp,
2672 extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
2673 const unsigned long *old, const unsigned long *new, int bits);
2674 extern int bitmap_bitremap(int oldbit,
2675 const unsigned long *old, const unsigned long *new, int bits);
2676 extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
2677 extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
2678 extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
2686 static inline __attribute__((always_inline)) void bitmap_zero(unsigned long *dst, int nbits)
2691 int len = (((nbits)+32 -1)/32) * sizeof(unsigned long);
2692 memset(dst, 0, len);
2696 static inline __attribute__((always_inline)) void bitmap_fill(unsigned long *dst, int nbits)
2698 size_t nlongs = (((nbits)+32 -1)/32);
2700 int len = (nlongs - 1) * sizeof(unsigned long);
2701 memset(dst, 0xff, len);
2703 dst[nlongs - 1] = ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
2706 static inline __attribute__((always_inline)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
2712 int len = (((nbits)+32 -1)/32) * sizeof(unsigned long);
2713 memcpy(dst, src, len);
2717 static inline __attribute__((always_inline)) void bitmap_and(unsigned long *dst, const unsigned long *src1,
2718 const unsigned long *src2, int nbits)
2721 *dst = *src1 & *src2;
2723 __bitmap_and(dst, src1, src2, nbits);
2726 static inline __attribute__((always_inline)) void bitmap_or(unsigned long *dst, const unsigned long *src1,
2727 const unsigned long *src2, int nbits)
2730 *dst = *src1 | *src2;
2732 __bitmap_or(dst, src1, src2, nbits);
2735 static inline __attribute__((always_inline)) void bitmap_xor(unsigned long *dst, const unsigned long *src1,
2736 const unsigned long *src2, int nbits)
2739 *dst = *src1 ^ *src2;
2741 __bitmap_xor(dst, src1, src2, nbits);
2744 static inline __attribute__((always_inline)) void bitmap_andnot(unsigned long *dst, const unsigned long *src1,
2745 const unsigned long *src2, int nbits)
2748 *dst = *src1 & ~(*src2);
2750 __bitmap_andnot(dst, src1, src2, nbits);
2753 static inline __attribute__((always_inline)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
2757 *dst = ~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
2759 __bitmap_complement(dst, src, nbits);
2762 static inline __attribute__((always_inline)) int bitmap_equal(const unsigned long *src1,
2763 const unsigned long *src2, int nbits)
2766 return ! ((*src1 ^ *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
2768 return __bitmap_equal(src1, src2, nbits);
2771 static inline __attribute__((always_inline)) int bitmap_intersects(const unsigned long *src1,
2772 const unsigned long *src2, int nbits)
2775 return ((*src1 & *src2) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL )) != 0;
2777 return __bitmap_intersects(src1, src2, nbits);
2780 static inline __attribute__((always_inline)) int bitmap_subset(const unsigned long *src1,
2781 const unsigned long *src2, int nbits)
2784 return ! ((*src1 & ~(*src2)) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
2786 return __bitmap_subset(src1, src2, nbits);
2789 static inline __attribute__((always_inline)) int bitmap_empty(const unsigned long *src, int nbits)
2792 return ! (*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
2794 return __bitmap_empty(src, nbits);
2797 static inline __attribute__((always_inline)) int bitmap_full(const unsigned long *src, int nbits)
2800 return ! (~(*src) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
2802 return __bitmap_full(src, nbits);
2805 static inline __attribute__((always_inline)) int bitmap_weight(const unsigned long *src, int nbits)
2808 return hweight_long(*src & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL ));
2809 return __bitmap_weight(src, nbits);
2812 static inline __attribute__((always_inline)) void bitmap_shift_right(unsigned long *dst,
2813 const unsigned long *src, int n, int nbits)
2818 __bitmap_shift_right(dst, src, n, nbits);
2821 static inline __attribute__((always_inline)) void bitmap_shift_left(unsigned long *dst,
2822 const unsigned long *src, int n, int nbits)
2825 *dst = (*src << n) & ( ((nbits) % 32) ? (1UL<<((nbits) % 32))-1 : ~0UL );
2827 __bitmap_shift_left(dst, src, n, nbits);
2830 static inline __attribute__((always_inline)) int bitmap_parse(const char *buf, unsigned int buflen,
2831 unsigned long *maskp, int nmaskbits)
2833 return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
2835 # 87 "include/linux/cpumask.h" 2
2837 typedef struct { unsigned long bits[(((1)+32 -1)/32)]; } cpumask_t;
2838 extern cpumask_t _unused_cpumask_arg_;
2841 static inline __attribute__((always_inline)) void __cpu_set(int cpu, volatile cpumask_t *dstp)
2843 set_bit(cpu, dstp->bits);
2847 static inline __attribute__((always_inline)) void __cpu_clear(int cpu, volatile cpumask_t *dstp)
2849 clear_bit(cpu, dstp->bits);
2853 static inline __attribute__((always_inline)) void __cpus_setall(cpumask_t *dstp, int nbits)
2855 bitmap_fill(dstp->bits, nbits);
2859 static inline __attribute__((always_inline)) void __cpus_clear(cpumask_t *dstp, int nbits)
2861 bitmap_zero(dstp->bits, nbits);
2868 static inline __attribute__((always_inline)) int __cpu_test_and_set(int cpu, cpumask_t *addr)
2870 return test_and_set_bit(cpu, addr->bits);
2874 static inline __attribute__((always_inline)) void __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
2875 const cpumask_t *src2p, int nbits)
2877 bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
2881 static inline __attribute__((always_inline)) void __cpus_or(cpumask_t *dstp, const cpumask_t *src1p,
2882 const cpumask_t *src2p, int nbits)
2884 bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
2888 static inline __attribute__((always_inline)) void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
2889 const cpumask_t *src2p, int nbits)
2891 bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
2896 static inline __attribute__((always_inline)) void __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
2897 const cpumask_t *src2p, int nbits)
2899 bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
2903 static inline __attribute__((always_inline)) void __cpus_complement(cpumask_t *dstp,
2904 const cpumask_t *srcp, int nbits)
2906 bitmap_complement(dstp->bits, srcp->bits, nbits);
2910 static inline __attribute__((always_inline)) int __cpus_equal(const cpumask_t *src1p,
2911 const cpumask_t *src2p, int nbits)
2913 return bitmap_equal(src1p->bits, src2p->bits, nbits);
2917 static inline __attribute__((always_inline)) int __cpus_intersects(const cpumask_t *src1p,
2918 const cpumask_t *src2p, int nbits)
2920 return bitmap_intersects(src1p->bits, src2p->bits, nbits);
2924 static inline __attribute__((always_inline)) int __cpus_subset(const cpumask_t *src1p,
2925 const cpumask_t *src2p, int nbits)
2927 return bitmap_subset(src1p->bits, src2p->bits, nbits);
2931 static inline __attribute__((always_inline)) int __cpus_empty(const cpumask_t *srcp, int nbits)
2933 return bitmap_empty(srcp->bits, nbits);
2937 static inline __attribute__((always_inline)) int __cpus_full(const cpumask_t *srcp, int nbits)
2939 return bitmap_full(srcp->bits, nbits);
2943 static inline __attribute__((always_inline)) int __cpus_weight(const cpumask_t *srcp, int nbits)
2945 return bitmap_weight(srcp->bits, nbits);
2950 static inline __attribute__((always_inline)) void __cpus_shift_right(cpumask_t *dstp,
2951 const cpumask_t *srcp, int n, int nbits)
2953 bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
2958 static inline __attribute__((always_inline)) void __cpus_shift_left(cpumask_t *dstp,
2959 const cpumask_t *srcp, int n, int nbits)
2961 bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
2963 # 270 "include/linux/cpumask.h"
2964 static inline __attribute__((always_inline)) int __cpumask_scnprintf(char *buf, int len,
2965 const cpumask_t *srcp, int nbits)
2967 return bitmap_scnprintf(buf, len, srcp->bits, nbits);
2972 static inline __attribute__((always_inline)) int __cpumask_parse_user(const char *buf, int len,
2973 cpumask_t *dstp, int nbits)
2975 return bitmap_parse_user(buf, len, dstp->bits, nbits);
2980 static inline __attribute__((always_inline)) int __cpulist_scnprintf(char *buf, int len,
2981 const cpumask_t *srcp, int nbits)
2983 return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
2987 static inline __attribute__((always_inline)) int __cpulist_parse(const char *buf, cpumask_t *dstp, int nbits)
2989 return bitmap_parselist(buf, dstp->bits, nbits);
2994 static inline __attribute__((always_inline)) int __cpu_remap(int oldbit,
2995 const cpumask_t *oldp, const cpumask_t *newp, int nbits)
2997 return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
3002 static inline __attribute__((always_inline)) void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
3003 const cpumask_t *oldp, const cpumask_t *newp, int nbits)
3005 bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
3007 # 380 "include/linux/cpumask.h"
3008 extern cpumask_t cpu_possible_map;
3009 extern cpumask_t cpu_online_map;
3010 extern cpumask_t cpu_present_map;
3011 # 55 "include/linux/sched.h" 2
3012 # 1 "include/linux/errno.h" 1
3016 # 1 "include/asm/errno.h" 1
3020 # 1 "include/asm-generic/errno.h" 1
3024 # 1 "include/asm-generic/errno-base.h" 1
3025 # 5 "include/asm-generic/errno.h" 2
3026 # 5 "include/asm/errno.h" 2
3027 # 5 "include/linux/errno.h" 2
3028 # 56 "include/linux/sched.h" 2
3029 # 1 "include/linux/nodemask.h" 1
3030 # 86 "include/linux/nodemask.h"
3031 # 1 "include/linux/numa.h" 1
3032 # 87 "include/linux/nodemask.h" 2
3034 typedef struct { unsigned long bits[((((1 << 0))+32 -1)/32)]; } nodemask_t;
3035 extern nodemask_t _unused_nodemask_arg_;
3038 static inline __attribute__((always_inline)) void __node_set(int node, volatile nodemask_t *dstp)
3040 set_bit(node, dstp->bits);
3044 static inline __attribute__((always_inline)) void __node_clear(int node, volatile nodemask_t *dstp)
3046 clear_bit(node, dstp->bits);
3050 static inline __attribute__((always_inline)) void __nodes_setall(nodemask_t *dstp, int nbits)
3052 bitmap_fill(dstp->bits, nbits);
3056 static inline __attribute__((always_inline)) void __nodes_clear(nodemask_t *dstp, int nbits)
3058 bitmap_zero(dstp->bits, nbits);
3066 static inline __attribute__((always_inline)) int __node_test_and_set(int node, nodemask_t *addr)
3068 return test_and_set_bit(node, addr->bits);
3073 static inline __attribute__((always_inline)) void __nodes_and(nodemask_t *dstp, const nodemask_t *src1p,
3074 const nodemask_t *src2p, int nbits)
3076 bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
3081 static inline __attribute__((always_inline)) void __nodes_or(nodemask_t *dstp, const nodemask_t *src1p,
3082 const nodemask_t *src2p, int nbits)
3084 bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
3089 static inline __attribute__((always_inline)) void __nodes_xor(nodemask_t *dstp, const nodemask_t *src1p,
3090 const nodemask_t *src2p, int nbits)
3092 bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
3097 static inline __attribute__((always_inline)) void __nodes_andnot(nodemask_t *dstp, const nodemask_t *src1p,
3098 const nodemask_t *src2p, int nbits)
3100 bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
3105 static inline __attribute__((always_inline)) void __nodes_complement(nodemask_t *dstp,
3106 const nodemask_t *srcp, int nbits)
3108 bitmap_complement(dstp->bits, srcp->bits, nbits);
3113 static inline __attribute__((always_inline)) int __nodes_equal(const nodemask_t *src1p,
3114 const nodemask_t *src2p, int nbits)
3116 return bitmap_equal(src1p->bits, src2p->bits, nbits);
3121 static inline __attribute__((always_inline)) int __nodes_intersects(const nodemask_t *src1p,
3122 const nodemask_t *src2p, int nbits)
3124 return bitmap_intersects(src1p->bits, src2p->bits, nbits);
3129 static inline __attribute__((always_inline)) int __nodes_subset(const nodemask_t *src1p,
3130 const nodemask_t *src2p, int nbits)
3132 return bitmap_subset(src1p->bits, src2p->bits, nbits);
3136 static inline __attribute__((always_inline)) int __nodes_empty(const nodemask_t *srcp, int nbits)
3138 return bitmap_empty(srcp->bits, nbits);
3142 static inline __attribute__((always_inline)) int __nodes_full(const nodemask_t *srcp, int nbits)
3144 return bitmap_full(srcp->bits, nbits);
3148 static inline __attribute__((always_inline)) int __nodes_weight(const nodemask_t *srcp, int nbits)
3150 return bitmap_weight(srcp->bits, nbits);
3155 static inline __attribute__((always_inline)) void __nodes_shift_right(nodemask_t *dstp,
3156 const nodemask_t *srcp, int n, int nbits)
3158 bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
3163 static inline __attribute__((always_inline)) void __nodes_shift_left(nodemask_t *dstp,
3164 const nodemask_t *srcp, int n, int nbits)
3166 bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
3173 static inline __attribute__((always_inline)) int __first_node(const nodemask_t *srcp)
3175 return ({ int __x = ((1 << 0)); int __y = (find_next_bit((srcp->bits), ((1 << 0)), 0)); __x < __y ? __x: __y; });
3179 static inline __attribute__((always_inline)) int __next_node(int n, const nodemask_t *srcp)
3181 return ({ int __x = ((1 << 0)); int __y = (find_next_bit(srcp->bits, (1 << 0), n+1)); __x < __y ? __x: __y; });
3183 # 251 "include/linux/nodemask.h"
3184 static inline __attribute__((always_inline)) int __first_unset_node(const nodemask_t *maskp)
3186 return ({ int __x = ((1 << 0)); int __y = (find_next_zero_bit((maskp->bits), ((1 << 0)), 0)); __x < __y ? __x: __y; });
3189 # 285 "include/linux/nodemask.h"
3190 static inline __attribute__((always_inline)) int __nodemask_scnprintf(char *buf, int len,
3191 const nodemask_t *srcp, int nbits)
3193 return bitmap_scnprintf(buf, len, srcp->bits, nbits);
3198 static inline __attribute__((always_inline)) int __nodemask_parse_user(const char *buf, int len,
3199 nodemask_t *dstp, int nbits)
3201 return bitmap_parse_user(buf, len, dstp->bits, nbits);
3206 static inline __attribute__((always_inline)) int __nodelist_scnprintf(char *buf, int len,
3207 const nodemask_t *srcp, int nbits)
3209 return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
3213 static inline __attribute__((always_inline)) int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
3215 return bitmap_parselist(buf, dstp->bits, nbits);
3220 static inline __attribute__((always_inline)) int __node_remap(int oldbit,
3221 const nodemask_t *oldp, const nodemask_t *newp, int nbits)
3223 return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
3228 static inline __attribute__((always_inline)) void __nodes_remap(nodemask_t *dstp, const nodemask_t *srcp,
3229 const nodemask_t *oldp, const nodemask_t *newp, int nbits)
3231 bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
3233 # 345 "include/linux/nodemask.h"
3234 extern nodemask_t node_online_map;
3235 extern nodemask_t node_possible_map;
3236 # 57 "include/linux/sched.h" 2
3239 # 1 "include/asm/semaphore.h" 1
3246 # 1 "include/linux/wait.h" 1
3247 # 22 "include/linux/wait.h"
3248 # 1 "include/linux/list.h" 1
3255 # 1 "include/linux/poison.h" 1
3256 # 8 "include/linux/list.h" 2
3257 # 1 "include/linux/prefetch.h" 1
3258 # 14 "include/linux/prefetch.h"
3259 # 1 "include/asm/processor.h" 1
3260 # 11 "include/asm/processor.h"
3261 # 1 "include/asm/segment.h" 1
3262 # 12 "include/asm/processor.h" 2
3265 static inline __attribute__((always_inline)) unsigned long rdusp(void)
3269 __asm__ __volatile__("%0 = usp;\n\t":"=da"(usp));
3273 static inline __attribute__((always_inline)) void wrusp(unsigned long usp)
3275 __asm__ __volatile__("usp = %0;\n\t"::"da"(usp));
3281 extern unsigned long memory_end;
3286 struct thread_struct {
3289 unsigned short seqstat;
3292 void * debuggerinfo;
3294 # 70 "include/asm/processor.h"
3298 static inline __attribute__((always_inline)) void release_thread(struct task_struct *dead_task)
3304 extern int kernel_thread(int (*fn) (void *), void *arg, unsigned long flags);
3309 static inline __attribute__((always_inline)) void exit_thread(void)
3318 unsigned long get_wchan(struct task_struct *p);
3319 # 107 "include/asm/processor.h"
3320 static inline __attribute__((always_inline)) __attribute__((pure)) uint32_t bfin_revid(void)
3323 return ({ unsigned __v; __asm__ __volatile__ ("NOP;\n\t" "%0 = [%1];\n\t" : "=d"(__v) : "a"(0xFFC00014)); __v; }) >> 28;
3326 static inline __attribute__((always_inline)) __attribute__((pure)) uint32_t bfin_compiled_revid(void)
3342 # 15 "include/linux/prefetch.h" 2
3343 # 1 "include/asm/cache.h" 1
3344 # 16 "include/linux/prefetch.h" 2
3345 # 43 "include/linux/prefetch.h"
3346 static inline __attribute__((always_inline)) void prefetch(const void *x) {;}
3350 static inline __attribute__((always_inline)) void prefetchw(const void *x) {;}
3351 # 58 "include/linux/prefetch.h"
3352 static inline __attribute__((always_inline)) void prefetch_range(void *addr, size_t len)
3362 # 9 "include/linux/list.h" 2
3363 # 21 "include/linux/list.h"
3365 struct list_head *next, *prev;
3373 static inline __attribute__((always_inline)) void INIT_LIST_HEAD(struct list_head *list)
3378 # 43 "include/linux/list.h"
3379 static inline __attribute__((always_inline)) void __list_add(struct list_head *new,
3380 struct list_head *prev,
3381 struct list_head *next)
3388 # 67 "include/linux/list.h"
3389 static inline __attribute__((always_inline)) void list_add(struct list_head *new, struct list_head *head)
3391 __list_add(new, head, head->next);
3393 # 84 "include/linux/list.h"
3394 static inline __attribute__((always_inline)) void list_add_tail(struct list_head *new, struct list_head *head)
3396 __list_add(new, head->prev, head);
3405 static inline __attribute__((always_inline)) void __list_add_rcu(struct list_head * new,
3406 struct list_head * prev, struct list_head * next)
3410 __asm__ __volatile__("": : :"memory");
3414 # 121 "include/linux/list.h"
3415 static inline __attribute__((always_inline)) void list_add_rcu(struct list_head *new, struct list_head *head)
3417 __list_add_rcu(new, head, head->next);
3419 # 142 "include/linux/list.h"
3420 static inline __attribute__((always_inline)) void list_add_tail_rcu(struct list_head *new,
3421 struct list_head *head)
3423 __list_add_rcu(new, head->prev, head);
3425 # 155 "include/linux/list.h"
3426 static inline __attribute__((always_inline)) void __list_del(struct list_head * prev, struct list_head * next)
3431 # 168 "include/linux/list.h"
3432 static inline __attribute__((always_inline)) void list_del(struct list_head *entry)
3434 __list_del(entry->prev, entry->next);
3435 entry->next = ((void *) 0x00100100);
3436 entry->prev = ((void *) 0x00200200);
3438 # 202 "include/linux/list.h"
3439 static inline __attribute__((always_inline)) void list_del_rcu(struct list_head *entry)
3441 __list_del(entry->prev, entry->next);
3442 entry->prev = ((void *) 0x00200200);
3444 # 215 "include/linux/list.h"
3445 static inline __attribute__((always_inline)) void list_replace(struct list_head *old,
3446 struct list_head *new)
3448 new->next = old->next;
3449 new->next->prev = new;
3450 new->prev = old->prev;
3451 new->prev->next = new;
3454 static inline __attribute__((always_inline)) void list_replace_init(struct list_head *old,
3455 struct list_head *new)
3457 list_replace(old, new);
3458 INIT_LIST_HEAD(old);
3460 # 239 "include/linux/list.h"
3461 static inline __attribute__((always_inline)) void list_replace_rcu(struct list_head *old,
3462 struct list_head *new)
3464 new->next = old->next;
3465 new->prev = old->prev;
3466 __asm__ __volatile__("": : :"memory");
3467 new->next->prev = new;
3468 new->prev->next = new;
3469 old->prev = ((void *) 0x00200200);
3476 static inline __attribute__((always_inline)) void list_del_init(struct list_head *entry)
3478 __list_del(entry->prev, entry->next);
3479 INIT_LIST_HEAD(entry);
3487 static inline __attribute__((always_inline)) void list_move(struct list_head *list, struct list_head *head)
3489 __list_del(list->prev, list->next);
3490 list_add(list, head);
3498 static inline __attribute__((always_inline)) void list_move_tail(struct list_head *list,
3499 struct list_head *head)
3501 __list_del(list->prev, list->next);
3502 list_add_tail(list, head);
3510 static inline __attribute__((always_inline)) int list_is_last(const struct list_head *list,
3511 const struct list_head *head)
3513 return list->next == head;
3520 static inline __attribute__((always_inline)) int list_empty(const struct list_head *head)
3522 return head->next == head;
3524 # 316 "include/linux/list.h"
3525 static inline __attribute__((always_inline)) int list_empty_careful(const struct list_head *head)
3527 struct list_head *next = head->next;
3528 return (next == head) && (next == head->prev);
3531 static inline __attribute__((always_inline)) void __list_splice(struct list_head *list,
3532 struct list_head *head)
3534 struct list_head *first = list->next;
3535 struct list_head *last = list->prev;
3536 struct list_head *at = head->next;
3550 static inline __attribute__((always_inline)) void list_splice(struct list_head *list, struct list_head *head)
3552 if (!list_empty(list))
3553 __list_splice(list, head);
3555 # 354 "include/linux/list.h"
3556 static inline __attribute__((always_inline)) void list_splice_init(struct list_head *list,
3557 struct list_head *head)
3559 if (!list_empty(list)) {
3560 __list_splice(list, head);
3561 INIT_LIST_HEAD(list);
3564 # 380 "include/linux/list.h"
3565 static inline __attribute__((always_inline)) void list_splice_init_rcu(struct list_head *list,
3566 struct list_head *head,
3569 struct list_head *first = list->next;
3570 struct list_head *last = list->prev;
3571 struct list_head *at = head->next;
3573 if (list_empty(head))
3578 INIT_LIST_HEAD(list);
3579 # 402 "include/linux/list.h"
3581 # 412 "include/linux/list.h"
3583 __asm__ __volatile__("": : :"memory");
3588 # 664 "include/linux/list.h"
3590 struct hlist_node *first;
3594 struct hlist_node *next, **pprev;
3600 static inline __attribute__((always_inline)) void INIT_HLIST_NODE(struct hlist_node *h)
3602 h->next = ((void *)0);
3603 h->pprev = ((void *)0);
3606 static inline __attribute__((always_inline)) int hlist_unhashed(const struct hlist_node *h)
3611 static inline __attribute__((always_inline)) int hlist_empty(const struct hlist_head *h)
3616 static inline __attribute__((always_inline)) void __hlist_del(struct hlist_node *n)
3618 struct hlist_node *next = n->next;
3619 struct hlist_node **pprev = n->pprev;
3622 next->pprev = pprev;
3625 static inline __attribute__((always_inline)) void hlist_del(struct hlist_node *n)
3628 n->next = ((void *) 0x00100100);
3629 n->pprev = ((void *) 0x00200200);
3631 # 726 "include/linux/list.h"
3632 static inline __attribute__((always_inline)) void hlist_del_rcu(struct hlist_node *n)
3635 n->pprev = ((void *) 0x00200200);
3638 static inline __attribute__((always_inline)) void hlist_del_init(struct hlist_node *n)
3640 if (!hlist_unhashed(n)) {
3645 # 747 "include/linux/list.h"
3646 static inline __attribute__((always_inline)) void hlist_replace_rcu(struct hlist_node *old,
3647 struct hlist_node *new)
3649 struct hlist_node *next = old->next;
3652 new->pprev = old->pprev;
3653 __asm__ __volatile__("": : :"memory");
3655 new->next->pprev = &new->next;
3657 old->pprev = ((void *) 0x00200200);
3660 static inline __attribute__((always_inline)) void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
3662 struct hlist_node *first = h->first;
3665 first->pprev = &n->next;
3667 n->pprev = &h->first;
3669 # 791 "include/linux/list.h"
3670 static inline __attribute__((always_inline)) void hlist_add_head_rcu(struct hlist_node *n,
3671 struct hlist_head *h)
3673 struct hlist_node *first = h->first;
3675 n->pprev = &h->first;
3676 __asm__ __volatile__("": : :"memory");
3678 first->pprev = &n->next;
3683 static inline __attribute__((always_inline)) void hlist_add_before(struct hlist_node *n,
3684 struct hlist_node *next)
3686 n->pprev = next->pprev;
3688 next->pprev = &n->next;
3692 static inline __attribute__((always_inline)) void hlist_add_after(struct hlist_node *n,
3693 struct hlist_node *next)
3695 next->next = n->next;
3697 next->pprev = &n->next;
3700 next->next->pprev = &next->next;
3702 # 842 "include/linux/list.h"
3703 static inline __attribute__((always_inline)) void hlist_add_before_rcu(struct hlist_node *n,
3704 struct hlist_node *next)
3706 n->pprev = next->pprev;
3708 __asm__ __volatile__("": : :"memory");
3709 next->pprev = &n->next;
3712 # 870 "include/linux/list.h"
3713 static inline __attribute__((always_inline)) void hlist_add_after_rcu(struct hlist_node *prev,
3714 struct hlist_node *n)
3716 n->next = prev->next;
3717 n->pprev = &prev->next;
3718 __asm__ __volatile__("": : :"memory");
3721 n->next->pprev = &n->next;
3723 # 23 "include/linux/wait.h" 2
3729 typedef struct __wait_queue wait_queue_t;
3730 typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key);
3731 int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
3733 struct __wait_queue {
3737 wait_queue_func_t func;
3738 struct list_head task_list;
3741 struct wait_bit_key {
3746 struct wait_bit_queue {
3747 struct wait_bit_key key;
3751 struct __wait_queue_head {
3753 struct list_head task_list;
3755 typedef struct __wait_queue_head wait_queue_head_t;
3758 # 80 "include/linux/wait.h"
3759 extern void init_waitqueue_head(wait_queue_head_t *q);
3760 # 91 "include/linux/wait.h"
3761 static inline __attribute__((always_inline)) void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
3765 q->func = default_wake_function;
3768 static inline __attribute__((always_inline)) void init_waitqueue_func_entry(wait_queue_t *q,
3769 wait_queue_func_t func)
3772 q->private = ((void *)0);
3776 static inline __attribute__((always_inline)) int waitqueue_active(wait_queue_head_t *q)
3778 return !list_empty(&q->task_list);
3780 # 120 "include/linux/wait.h"
3781 extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait);
3782 extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait);
3783 extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait);
3785 static inline __attribute__((always_inline)) void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
3787 list_add(&new->task_list, &head->task_list);
3793 static inline __attribute__((always_inline)) void __add_wait_queue_tail(wait_queue_head_t *head,
3796 list_add_tail(&new->task_list, &head->task_list);
3799 static inline __attribute__((always_inline)) void __remove_wait_queue(wait_queue_head_t *head,
3802 list_del(&old->task_list);
3805 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
3806 extern void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
3807 extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
3808 void __wake_up_bit(wait_queue_head_t *, void *, int);
3809 int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
3810 int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
3811 void wake_up_bit(void *, int);
3812 int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned);
3813 int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned);
3814 wait_queue_head_t *bit_waitqueue(void *, int);
3815 # 351 "include/linux/wait.h"
3816 static inline __attribute__((always_inline)) void add_wait_queue_exclusive_locked(wait_queue_head_t *q,
3817 wait_queue_t * wait)
3819 wait->flags |= 0x01;
3820 __add_wait_queue_tail(q, wait);
3826 static inline __attribute__((always_inline)) void remove_wait_queue_locked(wait_queue_head_t *q,
3827 wait_queue_t * wait)
3829 __remove_wait_queue(q, wait);
3837 extern void sleep_on(wait_queue_head_t *q);
3838 extern long sleep_on_timeout(wait_queue_head_t *q, signed long timeout);
3840 extern void interruptible_sleep_on(wait_queue_head_t *q);
3841 extern long interruptible_sleep_on_timeout(wait_queue_head_t *q, signed long timeout);
3847 void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state);
3849 void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state);
3851 void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
3852 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
3853 int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
3854 # 429 "include/linux/wait.h"
3855 static inline __attribute__((always_inline)) int wait_on_bit(void *word, int bit,
3856 int (*action)(void *), unsigned mode)
3858 if (!(__builtin_constant_p(bit) ? __constant_test_bit((bit),(word)) : __test_bit((bit),(word))))
3860 return out_of_line_wait_on_bit(word, bit, action, mode);
3862 # 453 "include/linux/wait.h"
3863 static inline __attribute__((always_inline)) int wait_on_bit_lock(void *word, int bit,
3864 int (*action)(void *), unsigned mode)
3866 if (!test_and_set_bit(bit, word))
3868 return out_of_line_wait_on_bit_lock(word, bit, action, mode);
3870 # 8 "include/asm/semaphore.h" 2
3872 # 1 "include/linux/rwsem.h" 1
3873 # 19 "include/linux/rwsem.h"
3874 struct rw_semaphore;
3877 # 1 "include/linux/rwsem-spinlock.h" 1
3878 # 22 "include/linux/rwsem-spinlock.h"
3879 struct rwsem_waiter;
3880 # 31 "include/linux/rwsem-spinlock.h"
3881 struct rw_semaphore {
3883 spinlock_t wait_lock;
3884 struct list_head wait_list;
3889 # 53 "include/linux/rwsem-spinlock.h"
3890 extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
3891 struct lock_class_key *key);
3892 # 63 "include/linux/rwsem-spinlock.h"
3893 extern void __down_read(struct rw_semaphore *sem);
3894 extern int __down_read_trylock(struct rw_semaphore *sem);
3895 extern void __down_write(struct rw_semaphore *sem);
3896 extern void __down_write_nested(struct rw_semaphore *sem, int subclass);
3897 extern int __down_write_trylock(struct rw_semaphore *sem);
3898 extern void __up_read(struct rw_semaphore *sem);
3899 extern void __up_write(struct rw_semaphore *sem);
3900 extern void __downgrade_write(struct rw_semaphore *sem);
3902 static inline __attribute__((always_inline)) int rwsem_is_locked(struct rw_semaphore *sem)
3904 return (sem->activity != 0);
3906 # 23 "include/linux/rwsem.h" 2
3914 extern void down_read(struct rw_semaphore *sem);
3919 extern int down_read_trylock(struct rw_semaphore *sem);
3924 extern void down_write(struct rw_semaphore *sem);
3929 extern int down_write_trylock(struct rw_semaphore *sem);
3934 extern void up_read(struct rw_semaphore *sem);
3939 extern void up_write(struct rw_semaphore *sem);
3944 extern void downgrade_write(struct rw_semaphore *sem);
3945 # 10 "include/asm/semaphore.h" 2
3946 # 21 "include/asm/semaphore.h"
3950 wait_queue_head_t wait;
3952 # 40 "include/asm/semaphore.h"
3953 static inline __attribute__((always_inline)) void sema_init(struct semaphore *sem, int val)
3955 *sem = (struct semaphore){ .count = { (val) }, .sleepers = 0, .wait = { .lock = (spinlock_t) { .raw_lock = { }, }, .task_list = { &((*sem).wait).task_list, &((*sem).wait).task_list } } };
3958 static inline __attribute__((always_inline)) void init_MUTEX(struct semaphore *sem)
3963 static inline __attribute__((always_inline)) void init_MUTEX_LOCKED(struct semaphore *sem)
3968 void __down(struct semaphore *sem);
3969 int __down_interruptible(struct semaphore *sem);
3970 int __down_trylock(struct semaphore *sem);
3971 void __up(struct semaphore *sem);
3973 extern spinlock_t semaphore_wake_lock;
3980 static inline __attribute__((always_inline)) void down(struct semaphore *sem)
3982 do { cond_resched(); } while (0);
3983 if (atomic_sub_return(1,(&sem->count)) < 0)
3987 static inline __attribute__((always_inline)) int down_interruptible(struct semaphore *sem)
3991 do { cond_resched(); } while (0);
3992 if (atomic_sub_return(1,(&sem->count)) < 0)
3993 ret = __down_interruptible(sem);
3997 static inline __attribute__((always_inline)) int down_trylock(struct semaphore *sem)
4001 if (atomic_sub_return(1,(&sem->count)) < 0)
4002 ret = __down_trylock(sem);
4012 static inline __attribute__((always_inline)) void up(struct semaphore *sem)
4014 if (atomic_add_return(1,(&sem->count)) <= 0)
4017 # 60 "include/linux/sched.h" 2
4020 # 1 "include/asm/mmu.h" 1
4026 struct sram_list_struct {
4027 struct sram_list_struct *next;
4033 struct vm_list_struct *vmlist;
4034 unsigned long end_brk;
4035 unsigned long stack_start;
4039 void *l1_stack_save;
4041 struct sram_list_struct *sram_list;
4044 unsigned long exec_fdpic_loadmap;
4045 unsigned long interp_fdpic_loadmap;
4049 # 63 "include/linux/sched.h" 2
4050 # 1 "include/asm/cputime.h" 1
4054 # 1 "include/asm-generic/cputime.h" 1
4061 typedef unsigned long cputime_t;
4062 # 23 "include/asm-generic/cputime.h"
4063 typedef u64 cputime64_t;
4064 # 5 "include/asm/cputime.h" 2
4065 # 64 "include/linux/sched.h" 2
4067 # 1 "include/linux/smp.h" 1
4068 # 10 "include/linux/smp.h"
4069 extern void cpu_idle(void);
4070 # 87 "include/linux/smp.h"
4071 static inline __attribute__((always_inline)) int up_smp_call_function(void)
4075 # 99 "include/linux/smp.h"
4076 static inline __attribute__((always_inline)) void smp_send_reschedule(int cpu) { }
4079 static inline __attribute__((always_inline)) int smp_call_function_single(int cpuid, void (*func) (void *info),
4080 void *info, int retry, int wait)
4086 # 138 "include/linux/smp.h"
4087 void smp_setup_processor_id(void);
4088 # 66 "include/linux/sched.h" 2
4089 # 1 "include/linux/sem.h" 1
4093 # 1 "include/linux/ipc.h" 1
4094 # 9 "include/linux/ipc.h"
4100 __kernel_uid_t cuid;
4101 __kernel_gid_t cgid;
4102 __kernel_mode_t mode;
4107 # 1 "include/asm/ipcbuf.h" 1
4108 # 16 "include/asm/ipcbuf.h"
4111 __kernel_uid32_t uid;
4112 __kernel_gid32_t gid;
4113 __kernel_uid32_t cuid;
4114 __kernel_gid32_t cgid;
4115 __kernel_mode_t mode;
4116 unsigned short __pad1;
4118 unsigned short __pad2;
4119 unsigned long __unused1;
4120 unsigned long __unused2;
4122 # 22 "include/linux/ipc.h" 2
4123 # 54 "include/linux/ipc.h"
4124 # 1 "include/linux/kref.h" 1
4125 # 23 "include/linux/kref.h"
4130 void kref_init(struct kref *kref);
4131 void kref_get(struct kref *kref);
4132 int kref_put(struct kref *kref, void (*release) (struct kref *kref));
4133 # 55 "include/linux/ipc.h" 2
4138 struct kern_ipc_perm
4153 struct ipc_namespace {
4155 struct ipc_ids *ids[3];
4170 extern struct ipc_namespace init_ipc_ns;
4174 extern int copy_ipcs(unsigned long flags, struct task_struct *tsk);
4175 # 107 "include/linux/ipc.h"
4176 static inline __attribute__((always_inline)) struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
4185 static inline __attribute__((always_inline)) void put_ipc_ns(struct ipc_namespace *ns)
4191 # 5 "include/linux/sem.h" 2
4192 # 23 "include/linux/sem.h"
4194 struct ipc_perm sem_perm;
4195 __kernel_time_t sem_otime;
4196 __kernel_time_t sem_ctime;
4197 struct sem *sem_base;
4198 struct sem_queue *sem_pending;
4199 struct sem_queue **sem_pending_last;
4200 struct sem_undo *undo;
4201 unsigned short sem_nsems;
4205 # 1 "include/asm/sembuf.h" 1
4206 # 14 "include/asm/sembuf.h"
4208 struct ipc64_perm sem_perm;
4209 __kernel_time_t sem_otime;
4210 unsigned long __unused1;
4211 __kernel_time_t sem_ctime;
4212 unsigned long __unused2;
4213 unsigned long sem_nsems;
4214 unsigned long __unused3;
4215 unsigned long __unused4;
4217 # 36 "include/linux/sem.h" 2
4221 unsigned short sem_num;
4229 struct semid_ds *buf;
4230 unsigned short *array;
4231 struct seminfo *__buf;
4247 # 82 "include/linux/sem.h"
4258 struct kern_ipc_perm sem_perm;
4262 struct sem *sem_base;
4263 struct sem_queue *sem_pending;
4264 struct sem_queue **sem_pending_last;
4265 struct sem_undo *undo;
4266 unsigned long sem_nsems;
4271 struct sem_queue * next;
4272 struct sem_queue ** prev;
4273 struct task_struct* sleeper;
4274 struct sem_undo * undo;
4277 struct sem_array * sma;
4279 struct sembuf * sops;
4288 struct sem_undo * proc_next;
4289 struct sem_undo * id_next;
4297 struct sem_undo_list {
4300 struct sem_undo *proc_list;
4304 struct sem_undo_list *undo_list;
4309 extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
4310 extern void exit_sem(struct task_struct *tsk);
4311 # 67 "include/linux/sched.h" 2
4312 # 1 "include/linux/signal.h" 1
4316 # 1 "include/asm/signal.h" 1
4324 # 17 "include/asm/signal.h"
4325 typedef unsigned long old_sigset_t;
4328 unsigned long sig[(64 / 32)];
4330 # 107 "include/asm/signal.h"
4331 # 1 "include/asm-generic/signal.h" 1
4332 # 17 "include/asm-generic/signal.h"
4333 typedef void __signalfn_t(int);
4334 typedef __signalfn_t *__sighandler_t;
4336 typedef void __restorefn_t(void);
4337 typedef __restorefn_t *__sigrestore_t;
4338 # 108 "include/asm/signal.h" 2
4341 struct old_sigaction {
4342 __sighandler_t sa_handler;
4343 old_sigset_t sa_mask;
4344 unsigned long sa_flags;
4345 void (*sa_restorer) (void);
4349 __sighandler_t sa_handler;
4350 unsigned long sa_flags;
4351 void (*sa_restorer) (void);
4355 struct k_sigaction {
4356 struct sigaction sa;
4358 # 145 "include/asm/signal.h"
4359 typedef struct sigaltstack {
4367 # 1 "include/asm/sigcontext.h" 1
4373 unsigned long sc_r0;
4374 unsigned long sc_r1;
4375 unsigned long sc_r2;
4376 unsigned long sc_r3;
4377 unsigned long sc_r4;
4378 unsigned long sc_r5;
4379 unsigned long sc_r6;
4380 unsigned long sc_r7;
4381 unsigned long sc_p0;
4382 unsigned long sc_p1;
4383 unsigned long sc_p2;
4384 unsigned long sc_p3;
4385 unsigned long sc_p4;
4386 unsigned long sc_p5;
4387 unsigned long sc_usp;
4388 unsigned long sc_a0w;
4389 unsigned long sc_a1w;
4390 unsigned long sc_a0x;
4391 unsigned long sc_a1x;
4392 unsigned long sc_astat;
4393 unsigned long sc_rets;
4394 unsigned long sc_pc;
4395 unsigned long sc_retx;
4396 unsigned long sc_fp;
4397 unsigned long sc_i0;
4398 unsigned long sc_i1;
4399 unsigned long sc_i2;
4400 unsigned long sc_i3;
4401 unsigned long sc_m0;
4402 unsigned long sc_m1;
4403 unsigned long sc_m2;
4404 unsigned long sc_m3;
4405 unsigned long sc_l0;
4406 unsigned long sc_l1;
4407 unsigned long sc_l2;
4408 unsigned long sc_l3;
4409 unsigned long sc_b0;
4410 unsigned long sc_b1;
4411 unsigned long sc_b2;
4412 unsigned long sc_b3;
4413 unsigned long sc_lc0;
4414 unsigned long sc_lc1;
4415 unsigned long sc_lt0;
4416 unsigned long sc_lt1;
4417 unsigned long sc_lb0;
4418 unsigned long sc_lb1;
4419 unsigned long sc_seqstat;
4421 # 154 "include/asm/signal.h" 2
4422 # 5 "include/linux/signal.h" 2
4423 # 1 "include/asm/siginfo.h" 1
4428 # 1 "include/asm-generic/siginfo.h" 1
4435 typedef union sigval {
4439 # 40 "include/asm-generic/siginfo.h"
4440 typedef struct siginfo {
4446 int _pad[((128 - (3 * sizeof(int))) / sizeof(int))];
4458 char _pad[sizeof( uid_t) - sizeof(int)];
4494 # 251 "include/asm-generic/siginfo.h"
4495 typedef struct sigevent {
4496 sigval_t sigev_value;
4500 int _pad[((64 - (sizeof(int) * 2 + sizeof(sigval_t))) / sizeof(int))];
4504 void (*_function)(sigval_t);
4517 void do_schedule_next_timer(struct siginfo *info);
4523 static inline __attribute__((always_inline)) void copy_siginfo(struct siginfo *to, struct siginfo *from)
4525 if (from->si_code < 0)
4526 memcpy(to, from, sizeof(*to));
4529 memcpy(to, from, (3 * sizeof(int)) + sizeof(from->_sifields._sigchld));
4534 extern int copy_siginfo_to_user(struct siginfo *to, struct siginfo *from);
4535 # 6 "include/asm/siginfo.h" 2
4536 # 6 "include/linux/signal.h" 2
4537 # 15 "include/linux/signal.h"
4539 struct list_head list;
4542 struct user_struct *user;
4549 struct list_head list;
4552 # 39 "include/linux/signal.h"
4553 static inline __attribute__((always_inline)) void sigaddset(sigset_t *set, int _sig)
4555 unsigned long sig = _sig - 1;
4557 set->sig[0] |= 1UL << sig;
4559 set->sig[sig / 32] |= 1UL << (sig % 32);
4562 static inline __attribute__((always_inline)) void sigdelset(sigset_t *set, int _sig)
4564 unsigned long sig = _sig - 1;
4566 set->sig[0] &= ~(1UL << sig);
4568 set->sig[sig / 32] &= ~(1UL << (sig % 32));
4571 static inline __attribute__((always_inline)) int sigismember(sigset_t *set, int _sig)
4573 unsigned long sig = _sig - 1;
4575 return 1 & (set->sig[0] >> sig);
4577 return 1 & (set->sig[sig / 32] >> (sig % 32));
4580 static inline __attribute__((always_inline)) int sigfindinword(unsigned long word)
4582 return __ffs(~(~word));
4587 static inline __attribute__((always_inline)) int sigisemptyset(sigset_t *set)
4589 extern void _NSIG_WORDS_is_unsupported_size(void);
4590 switch ((64 / 32)) {
4592 return (set->sig[3] | set->sig[2] |
4593 set->sig[1] | set->sig[0]) == 0;
4595 return (set->sig[1] | set->sig[0]) == 0;
4597 return set->sig[0] == 0;
4599 _NSIG_WORDS_is_unsupported_size();
4603 # 120 "include/linux/signal.h"
4604 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(); } }
4607 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(); } }
4610 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(); } }
4611 # 150 "include/linux/signal.h"
4612 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(); } }
4617 static inline __attribute__((always_inline)) void sigemptyset(sigset_t *set)
4619 switch ((64 / 32)) {
4621 memset(set, 0, sizeof(sigset_t));
4623 case 2: set->sig[1] = 0;
4624 case 1: set->sig[0] = 0;
4629 static inline __attribute__((always_inline)) void sigfillset(sigset_t *set)
4631 switch ((64 / 32)) {
4633 memset(set, -1, sizeof(sigset_t));
4635 case 2: set->sig[1] = -1;
4636 case 1: set->sig[0] = -1;
4643 static inline __attribute__((always_inline)) void sigaddsetmask(sigset_t *set, unsigned long mask)
4645 set->sig[0] |= mask;
4648 static inline __attribute__((always_inline)) void sigdelsetmask(sigset_t *set, unsigned long mask)
4650 set->sig[0] &= ~mask;
4653 static inline __attribute__((always_inline)) int sigtestsetmask(sigset_t *set, unsigned long mask)
4655 return (set->sig[0] & mask) != 0;
4658 static inline __attribute__((always_inline)) void siginitset(sigset_t *set, unsigned long mask)
4661 switch ((64 / 32)) {
4663 memset(&set->sig[1], 0, sizeof(long)*((64 / 32)-1));
4665 case 2: set->sig[1] = 0;
4670 static inline __attribute__((always_inline)) void siginitsetinv(sigset_t *set, unsigned long mask)
4672 set->sig[0] = ~mask;
4673 switch ((64 / 32)) {
4675 memset(&set->sig[1], -1, sizeof(long)*((64 / 32)-1));
4677 case 2: set->sig[1] = -1;
4684 static inline __attribute__((always_inline)) void init_sigpending(struct sigpending *sig)
4686 sigemptyset(&sig->signal);
4687 INIT_LIST_HEAD(&sig->list);
4690 extern void flush_sigqueue(struct sigpending *queue);
4693 static inline __attribute__((always_inline)) int valid_signal(unsigned long sig)
4695 return sig <= 64 ? 1 : 0;
4698 extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
4699 extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
4700 extern long do_sigpending(void *, unsigned long);
4701 extern int sigprocmask(int, sigset_t *, sigset_t *);
4704 extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
4706 extern struct kmem_cache *sighand_cachep;
4707 # 68 "include/linux/sched.h" 2
4708 # 1 "include/linux/securebits.h" 1
4714 extern unsigned securebits;
4715 # 69 "include/linux/sched.h" 2
4716 # 1 "include/linux/fs_struct.h" 1
4727 struct dentry * root, * pwd, * altroot;
4728 struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
4737 extern struct kmem_cache *fs_cachep;
4739 extern void exit_fs(struct task_struct *);
4740 extern void set_fs_altroot(void);
4741 extern void set_fs_root(struct fs_struct *, struct vfsmount *, struct dentry *);
4742 extern void set_fs_pwd(struct fs_struct *, struct vfsmount *, struct dentry *);
4743 extern struct fs_struct *copy_fs_struct(struct fs_struct *);
4744 extern void put_fs_struct(struct fs_struct *);
4745 # 70 "include/linux/sched.h" 2
4747 # 1 "include/linux/completion.h" 1
4748 # 13 "include/linux/completion.h"
4751 wait_queue_head_t wait;
4753 # 39 "include/linux/completion.h"
4754 static inline __attribute__((always_inline)) void init_completion(struct completion *x)
4757 init_waitqueue_head(&x->wait);
4760 extern void wait_for_completion(struct completion *);
4761 extern int wait_for_completion_interruptible(struct completion *x);
4762 extern unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout);
4764 extern unsigned long wait_for_completion_interruptible_timeout( struct completion *x, unsigned long timeout);
4767 extern void complete(struct completion *);
4768 extern void complete_all(struct completion *);
4769 # 72 "include/linux/sched.h" 2
4770 # 1 "include/linux/pid.h" 1
4774 # 1 "include/linux/rcupdate.h" 1
4775 # 38 "include/linux/rcupdate.h"
4776 # 1 "include/linux/cache.h" 1
4777 # 39 "include/linux/rcupdate.h" 2
4780 # 1 "include/linux/percpu.h" 1
4785 # 1 "include/linux/slab.h" 1
4786 # 14 "include/linux/slab.h"
4787 # 1 "include/linux/gfp.h" 1
4791 # 1 "include/linux/mmzone.h" 1
4792 # 13 "include/linux/mmzone.h"
4793 # 1 "include/linux/init.h" 1
4794 # 63 "include/linux/init.h"
4795 typedef int (*initcall_t)(void);
4796 typedef void (*exitcall_t)(void);
4798 extern initcall_t __con_initcall_start[], __con_initcall_end[];
4799 extern initcall_t __security_initcall_start[], __security_initcall_end[];
4802 extern char __attribute__ ((__section__ (".init.data"))) boot_command_line[];
4803 extern char *saved_command_line;
4804 extern unsigned int reset_devices;
4807 extern void setup_arch(char **);
4808 # 134 "include/linux/init.h"
4809 struct obs_kernel_param {
4811 int (*setup_func)(char *);
4814 # 169 "include/linux/init.h"
4815 void __attribute__ ((__section__ (".init.text"))) parse_early_param(void);
4816 # 14 "include/linux/mmzone.h" 2
4817 # 27 "include/linux/mmzone.h"
4819 struct list_head free_list;
4820 unsigned long nr_free;
4824 # 49 "include/linux/mmzone.h"
4825 enum zone_stat_item {
4837 NR_SLAB_RECLAIMABLE,
4838 NR_SLAB_UNRECLAIMABLE,
4843 # 75 "include/linux/mmzone.h"
4844 NR_VM_ZONE_STAT_ITEMS };
4846 struct per_cpu_pages {
4850 struct list_head list;
4853 struct per_cpu_pageset {
4854 struct per_cpu_pages pcp[2];
4868 # 119 "include/linux/mmzone.h"
4870 # 134 "include/linux/mmzone.h"
4872 # 146 "include/linux/mmzone.h"
4875 # 179 "include/linux/mmzone.h"
4878 unsigned long pages_min, pages_low, pages_high;
4879 # 190 "include/linux/mmzone.h"
4880 unsigned long lowmem_reserve[MAX_NR_ZONES];
4882 unsigned long max_pagecache_pages;
4883 # 203 "include/linux/mmzone.h"
4884 struct per_cpu_pageset pageset[1];
4894 struct free_area free_area[14];
4902 spinlock_t lru_lock;
4903 struct list_head active_list;
4904 struct list_head inactive_list;
4905 unsigned long nr_scan_active;
4906 unsigned long nr_scan_inactive;
4907 unsigned long pages_scanned;
4908 int all_unreclaimable;
4911 atomic_t reclaim_in_progress;
4914 atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
4915 # 248 "include/linux/mmzone.h"
4920 # 278 "include/linux/mmzone.h"
4921 wait_queue_head_t * wait_table;
4922 unsigned long wait_table_hash_nr_entries;
4923 unsigned long wait_table_bits;
4928 struct pglist_data *zone_pgdat;
4930 unsigned long zone_start_pfn;
4931 # 299 "include/linux/mmzone.h"
4932 unsigned long spanned_pages;
4933 unsigned long present_pages;
4940 # 384 "include/linux/mmzone.h"
4941 struct zonelist_cache;
4942 # 397 "include/linux/mmzone.h"
4944 struct zonelist_cache *zlcache_ptr;
4945 struct zone *zones[((1 << 0) * MAX_NR_ZONES) + 1];
4950 # 415 "include/linux/mmzone.h"
4951 extern struct page *mem_map;
4952 # 429 "include/linux/mmzone.h"
4953 struct bootmem_data;
4954 typedef struct pglist_data {
4955 struct zone node_zones[MAX_NR_ZONES];
4956 struct zonelist node_zonelists[MAX_NR_ZONES];
4959 struct page *node_mem_map;
4961 struct bootmem_data *bdata;
4962 # 448 "include/linux/mmzone.h"
4963 unsigned long node_start_pfn;
4964 unsigned long node_present_pages;
4965 unsigned long node_spanned_pages;
4968 wait_queue_head_t kswapd_wait;
4969 struct task_struct *kswapd;
4970 int kswapd_max_order;
4972 # 467 "include/linux/mmzone.h"
4973 # 1 "include/linux/memory_hotplug.h" 1
4977 # 1 "include/linux/mmzone.h" 1
4978 # 5 "include/linux/memory_hotplug.h" 2
4981 # 1 "include/linux/notifier.h" 1
4982 # 13 "include/linux/notifier.h"
4983 # 1 "include/linux/mutex.h" 1
4984 # 47 "include/linux/mutex.h"
4988 spinlock_t wait_lock;
4989 struct list_head wait_list;
4990 # 60 "include/linux/mutex.h"
4997 struct mutex_waiter {
4998 struct list_head list;
4999 struct task_struct *task;
5005 # 105 "include/linux/mutex.h"
5006 extern void __mutex_init(struct mutex *lock, const char *name,
5007 struct lock_class_key *key);
5015 static inline __attribute__((always_inline)) int mutex_is_locked(struct mutex *lock)
5017 return ((&lock->count)->counter) != 1;
5024 extern void mutex_lock(struct mutex *lock);
5025 extern int mutex_lock_interruptible(struct mutex *lock);
5026 # 138 "include/linux/mutex.h"
5027 extern int mutex_trylock(struct mutex *lock);
5028 extern void mutex_unlock(struct mutex *lock);
5029 # 14 "include/linux/notifier.h" 2
5031 # 1 "include/linux/srcu.h" 1
5032 # 30 "include/linux/srcu.h"
5033 struct srcu_struct_array {
5037 struct srcu_struct {
5039 struct srcu_struct_array *per_cpu_ref;
5049 int init_srcu_struct(struct srcu_struct *sp);
5050 void cleanup_srcu_struct(struct srcu_struct *sp);
5051 int srcu_read_lock(struct srcu_struct *sp) ;
5052 void srcu_read_unlock(struct srcu_struct *sp, int idx) ;
5053 void synchronize_srcu(struct srcu_struct *sp);
5054 long srcu_batches_completed(struct srcu_struct *sp);
5055 # 16 "include/linux/notifier.h" 2
5056 # 50 "include/linux/notifier.h"
5057 struct notifier_block {
5058 int (*notifier_call)(struct notifier_block *, unsigned long, void *);
5059 struct notifier_block *next;
5063 struct atomic_notifier_head {
5065 struct notifier_block *head;
5068 struct blocking_notifier_head {
5069 struct rw_semaphore rwsem;
5070 struct notifier_block *head;
5073 struct raw_notifier_head {
5074 struct notifier_block *head;
5077 struct srcu_notifier_head {
5079 struct srcu_struct srcu;
5080 struct notifier_block *head;
5082 # 89 "include/linux/notifier.h"
5083 extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
5084 # 115 "include/linux/notifier.h"
5085 extern int atomic_notifier_chain_register(struct atomic_notifier_head *,
5086 struct notifier_block *);
5087 extern int blocking_notifier_chain_register(struct blocking_notifier_head *,
5088 struct notifier_block *);
5089 extern int raw_notifier_chain_register(struct raw_notifier_head *,
5090 struct notifier_block *);
5091 extern int srcu_notifier_chain_register(struct srcu_notifier_head *,
5092 struct notifier_block *);
5094 extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *,
5095 struct notifier_block *);
5096 extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *,
5097 struct notifier_block *);
5098 extern int raw_notifier_chain_unregister(struct raw_notifier_head *,
5099 struct notifier_block *);
5100 extern int srcu_notifier_chain_unregister(struct srcu_notifier_head *,
5101 struct notifier_block *);
5103 extern int atomic_notifier_call_chain(struct atomic_notifier_head *,
5104 unsigned long val, void *v);
5105 extern int blocking_notifier_call_chain(struct blocking_notifier_head *,
5106 unsigned long val, void *v);
5107 extern int raw_notifier_call_chain(struct raw_notifier_head *,
5108 unsigned long val, void *v);
5109 extern int srcu_notifier_call_chain(struct srcu_notifier_head *,
5110 unsigned long val, void *v);
5111 # 8 "include/linux/memory_hotplug.h" 2
5116 # 140 "include/linux/memory_hotplug.h"
5117 static inline __attribute__((always_inline)) void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
5118 static inline __attribute__((always_inline)) void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
5119 static inline __attribute__((always_inline)) void pgdat_resize_init(struct pglist_data *pgdat) {}
5121 static inline __attribute__((always_inline)) unsigned zone_span_seqbegin(struct zone *zone)
5125 static inline __attribute__((always_inline)) int zone_span_seqretry(struct zone *zone, unsigned iv)
5129 static inline __attribute__((always_inline)) void zone_span_writelock(struct zone *zone) {}
5130 static inline __attribute__((always_inline)) void zone_span_writeunlock(struct zone *zone) {}
5131 static inline __attribute__((always_inline)) void zone_seqlock_init(struct zone *zone) {}
5133 static inline __attribute__((always_inline)) int mhp_notimplemented(const char *func)
5135 printk("<4>" "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n", func);
5141 static inline __attribute__((always_inline)) int __remove_pages(struct zone *zone, unsigned long start_pfn,
5142 unsigned long nr_pages)
5144 printk("<4>" "%s() called, not yet supported\n", (__func__));
5149 extern int add_memory(int nid, u64 start, u64 size);
5150 extern int arch_add_memory(int nid, u64 start, u64 size);
5151 extern int remove_memory(u64 start, u64 size);
5152 extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
5154 # 468 "include/linux/mmzone.h" 2
5156 void get_zone_counts(unsigned long *active, unsigned long *inactive,
5157 unsigned long *free);
5158 void build_all_zonelists(void);
5159 void wakeup_kswapd(struct zone *zone, int order);
5160 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
5161 int classzone_idx, int alloc_flags);
5162 enum memmap_context {
5166 extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
5168 enum memmap_context context);
5173 static inline __attribute__((always_inline)) void memory_present(int nid, unsigned long start, unsigned long end) {}
5174 # 498 "include/linux/mmzone.h"
5175 static inline __attribute__((always_inline)) int populated_zone(struct zone *zone)
5177 return (!!zone->present_pages);
5180 static inline __attribute__((always_inline)) int is_highmem_idx(enum zone_type idx)
5189 static inline __attribute__((always_inline)) int is_normal_idx(enum zone_type idx)
5191 return (idx == ZONE_NORMAL);
5200 static inline __attribute__((always_inline)) int is_highmem(struct zone *zone)
5209 static inline __attribute__((always_inline)) int is_normal(struct zone *zone)
5211 return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
5214 static inline __attribute__((always_inline)) int is_dma32(struct zone *zone)
5223 static inline __attribute__((always_inline)) int is_dma(struct zone *zone)
5226 return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
5235 int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *,
5236 void *, size_t *, loff_t *);
5237 extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
5238 int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
5239 void *, size_t *, loff_t *);
5240 int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
5241 void *, size_t *, loff_t *);
5242 int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
5243 struct file *, void *, size_t *, loff_t *);
5244 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
5245 struct file *, void *, size_t *, loff_t *);
5246 int sysctl_pagecache_ratio_sysctl_handler(struct ctl_table *, int,
5247 struct file *, void *, size_t *, loff_t *);
5249 # 1 "include/linux/topology.h" 1
5250 # 34 "include/linux/topology.h"
5251 # 1 "include/asm/topology.h" 1
5255 # 1 "include/asm-generic/topology.h" 1
5256 # 5 "include/asm/topology.h" 2
5257 # 35 "include/linux/topology.h" 2
5258 # 573 "include/linux/mmzone.h" 2
5266 extern struct pglist_data contig_page_data;
5267 # 591 "include/linux/mmzone.h"
5268 extern struct pglist_data *first_online_pgdat(void);
5269 extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
5270 extern struct zone *next_zone(struct zone *zone);
5271 # 790 "include/linux/mmzone.h"
5272 void memory_present(int nid, unsigned long start, unsigned long end);
5273 unsigned long __attribute__ ((__section__ (".init.text"))) node_memmap_size_bytes(int, unsigned long, unsigned long);
5274 # 5 "include/linux/gfp.h" 2
5278 struct vm_area_struct;
5279 # 87 "include/linux/gfp.h"
5280 static inline __attribute__((always_inline)) enum zone_type gfp_zone(gfp_t flags)
5283 if (flags & (( gfp_t)0x01u))
5285 # 101 "include/linux/gfp.h"
5288 # 120 "include/linux/gfp.h"
5289 static inline __attribute__((always_inline)) void arch_free_page(struct page *page, int order) { }
5292 static inline __attribute__((always_inline)) void arch_alloc_page(struct page *page, int order) { }
5295 extern struct page *
5296 __alloc_pages(gfp_t, unsigned int, struct zonelist *);
5298 static inline __attribute__((always_inline)) struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
5301 if (__builtin_expect(!!(order >= 14), 0))
5308 return __alloc_pages(gfp_mask, order,
5309 (&contig_page_data)->node_zonelists + gfp_zone(gfp_mask));
5311 # 163 "include/linux/gfp.h"
5312 extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
5313 extern unsigned long get_zeroed_page(gfp_t gfp_mask);
5321 extern void __free_pages(struct page *page, unsigned int order);
5322 extern void free_pages(unsigned long addr, unsigned int order);
5323 extern void free_hot_page(struct page *page);
5324 extern void free_cold_page(struct page *page);
5329 void page_alloc_init(void);
5333 static inline __attribute__((always_inline)) void drain_node_pages(int node) { };
5334 # 15 "include/linux/slab.h" 2
5337 typedef struct kmem_cache kmem_cache_t __attribute__((deprecated));
5338 # 44 "include/linux/slab.h"
5339 void __attribute__ ((__section__ (".init.text"))) kmem_cache_init(void);
5340 extern int slab_is_available(void);
5342 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
5344 void (*)(void *, struct kmem_cache *, unsigned long),
5345 void (*)(void *, struct kmem_cache *, unsigned long));
5346 void kmem_cache_destroy(struct kmem_cache *);
5347 int kmem_cache_shrink(struct kmem_cache *);
5348 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
5349 void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
5350 void kmem_cache_free(struct kmem_cache *, void *);
5351 unsigned int kmem_cache_size(struct kmem_cache *);
5352 const char *kmem_cache_name(struct kmem_cache *);
5353 int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
5358 static inline __attribute__((always_inline)) void *kmem_cache_alloc_node(struct kmem_cache *cachep,
5359 gfp_t flags, int node)
5361 return kmem_cache_alloc(cachep, flags);
5368 void *__kmalloc(size_t, gfp_t);
5369 void *__kzalloc(size_t, gfp_t);
5370 void kfree(const void *);
5371 unsigned int ksize(const void *);
5379 static inline __attribute__((always_inline)) void *kcalloc(size_t n, size_t size, gfp_t flags)
5381 if (n != 0 && size > (~0UL) / n)
5383 return __kzalloc(n * size, flags);
5385 # 98 "include/linux/slab.h"
5386 # 1 "include/linux/slab_def.h" 1
5387 # 19 "include/linux/slab_def.h"
5388 struct cache_sizes {
5390 struct kmem_cache *cs_cachep;
5392 struct kmem_cache *cs_dmacachep;
5395 extern struct cache_sizes malloc_sizes[];
5397 static inline __attribute__((always_inline)) void *kmalloc(size_t size, gfp_t flags)
5399 if (__builtin_constant_p(size)) {
5406 # 1 "include/linux/kmalloc_sizes.h" 1
5408 if (size <= 32) goto found; else i++;
5410 if (size <= 64) goto found; else i++;
5412 if (size <= 96) goto found; else i++;
5414 if (size <= 128) goto found; else i++;
5416 if (size <= 192) goto found; else i++;
5418 if (size <= 256) goto found; else i++;
5419 if (size <= 512) goto found; else i++;
5420 if (size <= 1024) goto found; else i++;
5421 if (size <= 2048) goto found; else i++;
5422 if (size <= 4096) goto found; else i++;
5423 if (size <= 8192) goto found; else i++;
5424 if (size <= 16384) goto found; else i++;
5425 if (size <= 32768) goto found; else i++;
5426 if (size <= 65536) goto found; else i++;
5427 if (size <= 131072) goto found; else i++;
5429 if (size <= 262144) goto found; else i++;
5432 if (size <= 524288) goto found; else i++;
5433 if (size <= 1048576) goto found; else i++;
5435 if (size <= 2097152) goto found; else i++;
5436 if (size <= 4194304) goto found; else i++;
5437 if (size <= 8388608) goto found; else i++;
5438 if (size <= 16777216) goto found; else i++;
5439 if (size <= 33554432) goto found; else i++;
5440 # 38 "include/linux/slab_def.h" 2
5443 extern void __you_cannot_kmalloc_that_much(void);
5444 __you_cannot_kmalloc_that_much();
5448 if (flags & (( gfp_t)0x01u))
5449 return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
5452 return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
5454 return __kmalloc(size, flags);
5457 static inline __attribute__((always_inline)) void *kzalloc(size_t size, gfp_t flags)
5459 if (__builtin_constant_p(size)) {
5466 # 1 "include/linux/kmalloc_sizes.h" 1
5468 if (size <= 32) goto found; else i++;
5470 if (size <= 64) goto found; else i++;
5472 if (size <= 96) goto found; else i++;
5474 if (size <= 128) goto found; else i++;
5476 if (size <= 192) goto found; else i++;
5478 if (size <= 256) goto found; else i++;
5479 if (size <= 512) goto found; else i++;
5480 if (size <= 1024) goto found; else i++;
5481 if (size <= 2048) goto found; else i++;
5482 if (size <= 4096) goto found; else i++;
5483 if (size <= 8192) goto found; else i++;
5484 if (size <= 16384) goto found; else i++;
5485 if (size <= 32768) goto found; else i++;
5486 if (size <= 65536) goto found; else i++;
5487 if (size <= 131072) goto found; else i++;
5489 if (size <= 262144) goto found; else i++;
5492 if (size <= 524288) goto found; else i++;
5493 if (size <= 1048576) goto found; else i++;
5495 if (size <= 2097152) goto found; else i++;
5496 if (size <= 4194304) goto found; else i++;
5497 if (size <= 8388608) goto found; else i++;
5498 if (size <= 16777216) goto found; else i++;
5499 if (size <= 33554432) goto found; else i++;
5500 # 64 "include/linux/slab_def.h" 2
5503 extern void __you_cannot_kzalloc_that_much(void);
5504 __you_cannot_kzalloc_that_much();
5508 if (flags & (( gfp_t)0x01u))
5509 return kmem_cache_zalloc(malloc_sizes[i].cs_dmacachep,
5512 return kmem_cache_zalloc(malloc_sizes[i].cs_cachep, flags);
5514 return __kzalloc(size, flags);
5516 # 99 "include/linux/slab.h" 2
5517 # 167 "include/linux/slab.h"
5518 static inline __attribute__((always_inline)) void *kmalloc_node(size_t size, gfp_t flags, int node)
5520 return kmalloc(size, flags);
5523 static inline __attribute__((always_inline)) void *__kmalloc_node(size_t size, gfp_t flags, int node)
5525 return __kmalloc(size, flags);
5527 # 6 "include/linux/percpu.h" 2
5532 # 1 "include/asm/percpu.h" 1
5536 # 1 "include/asm-generic/percpu.h" 1
5537 # 5 "include/asm/percpu.h" 2
5538 # 11 "include/linux/percpu.h" 2
5539 # 57 "include/linux/percpu.h"
5540 static inline __attribute__((always_inline)) void percpu_depopulate(void *__pdata, int cpu)
5544 static inline __attribute__((always_inline)) void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask)
5548 static inline __attribute__((always_inline)) void *percpu_populate(void *__pdata, size_t size, gfp_t gfp,
5551 return ({ (void)(cpu); (__pdata); });
5554 static inline __attribute__((always_inline)) int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
5560 static inline __attribute__((always_inline)) __attribute__((always_inline)) void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask)
5562 return kzalloc(size, gfp);
5565 static inline __attribute__((always_inline)) void percpu_free(void *__pdata)
5569 # 42 "include/linux/rcupdate.h" 2
5570 # 50 "include/linux/rcupdate.h"
5572 struct rcu_head *next;
5573 void (*func)(struct rcu_head *head);
5575 # 64 "include/linux/rcupdate.h"
5576 struct rcu_ctrlblk {
5589 static inline __attribute__((always_inline)) int rcu_batch_before(long a, long b)
5595 static inline __attribute__((always_inline)) int rcu_batch_after(long a, long b)
5613 struct rcu_head *nxtlist;
5614 struct rcu_head **nxttail;
5616 struct rcu_head *curlist;
5617 struct rcu_head **curtail;
5618 struct rcu_head *donelist;
5619 struct rcu_head **donetail;
5622 struct rcu_head barrier;
5625 extern __typeof__(struct rcu_data) per_cpu__rcu_data;
5626 extern __typeof__(struct rcu_data) per_cpu__rcu_bh_data;
5634 static inline __attribute__((always_inline)) void rcu_qsctr_inc(int cpu)
5636 struct rcu_data *rdp = &(*((void)(cpu), &per_cpu__rcu_data));
5637 rdp->passed_quiesc = 1;
5639 static inline __attribute__((always_inline)) void rcu_bh_qsctr_inc(int cpu)
5641 struct rcu_data *rdp = &(*((void)(cpu), &per_cpu__rcu_bh_data));
5642 rdp->passed_quiesc = 1;
5645 extern int rcu_pending(int cpu);
5646 extern int rcu_needs_cpu(int cpu);
5647 # 272 "include/linux/rcupdate.h"
5648 extern void rcu_init(void);
5649 extern void rcu_check_callbacks(int cpu, int user);
5650 extern void rcu_restart_cpu(int cpu);
5651 extern long rcu_batches_completed(void);
5652 extern long rcu_batches_completed_bh(void);
5655 extern void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *head));
5657 extern void call_rcu_bh(struct rcu_head *head, void (*func)(struct rcu_head *head));
5659 extern void synchronize_rcu(void);
5660 void synchronize_idle(void);
5661 extern void rcu_barrier(void);
5662 # 5 "include/linux/pid.h" 2
5671 # 43 "include/linux/pid.h"
5677 struct hlist_node pid_chain;
5679 struct hlist_head tasks[PIDTYPE_MAX];
5680 struct rcu_head rcu;
5685 struct hlist_node node;
5689 static inline __attribute__((always_inline)) struct pid *get_pid(struct pid *pid)
5692 atomic_inc(&pid->count);
5696 extern void put_pid(struct pid *pid);
5697 extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
5698 extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
5701 extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
5707 extern int attach_pid(struct task_struct *task, enum pid_type type, int nr);
5710 extern void detach_pid(struct task_struct *task, enum pid_type);
5711 extern void transfer_pid(struct task_struct *old, struct task_struct *new, enum pid_type);
5718 extern struct pid *find_pid(int nr);
5723 extern struct pid *find_get_pid(int nr);
5724 extern struct pid *find_ge_pid(int nr);
5726 extern struct pid *alloc_pid(void);
5727 extern void free_pid(struct pid *pid);
5729 static inline __attribute__((always_inline)) pid_t pid_nr(struct pid *pid)
5736 # 73 "include/linux/sched.h" 2
5739 # 1 "include/linux/seccomp.h" 1
5740 # 28 "include/linux/seccomp.h"
5741 typedef struct { } seccomp_t;
5745 static inline __attribute__((always_inline)) int has_secure_computing(struct thread_info *ti)
5749 # 76 "include/linux/sched.h" 2
5751 # 1 "include/linux/futex.h" 1
5755 # 1 "include/linux/sched.h" 1
5756 # 5 "include/linux/futex.h" 2
5757 # 33 "include/linux/futex.h"
5758 struct robust_list {
5759 struct robust_list *next;
5761 # 45 "include/linux/futex.h"
5762 struct robust_list_head {
5766 struct robust_list list;
5775 # 69 "include/linux/futex.h"
5776 struct robust_list *list_op_pending;
5778 # 97 "include/linux/futex.h"
5779 long do_futex(u32 *uaddr, int op, u32 val, unsigned long timeout,
5780 u32 *uaddr2, u32 val2, u32 val3);
5783 handle_futex_death(u32 *uaddr, struct task_struct *curr, int pi);
5786 extern void exit_robust_list(struct task_struct *curr);
5787 extern void exit_pi_state_list(struct task_struct *curr);
5788 # 78 "include/linux/sched.h" 2
5789 # 1 "include/linux/rtmutex.h" 1
5790 # 16 "include/linux/rtmutex.h"
5791 # 1 "include/linux/plist.h" 1
5792 # 80 "include/linux/plist.h"
5794 struct list_head prio_list;
5795 struct list_head node_list;
5803 struct plist_head plist;
5805 # 127 "include/linux/plist.h"
5806 static inline __attribute__((always_inline)) void
5807 plist_head_init(struct plist_head *head, spinlock_t *lock)
5809 INIT_LIST_HEAD(&head->prio_list);
5810 INIT_LIST_HEAD(&head->node_list);
5821 static inline __attribute__((always_inline)) void plist_node_init(struct plist_node *node, int prio)
5824 plist_head_init(&node->plist, ((void *)0));
5827 extern void plist_add(struct plist_node *node, struct plist_head *head);
5828 extern void plist_del(struct plist_node *node, struct plist_head *head);
5829 # 195 "include/linux/plist.h"
5830 static inline __attribute__((always_inline)) int plist_head_empty(const struct plist_head *head)
5832 return list_empty(&head->node_list);
5839 static inline __attribute__((always_inline)) int plist_node_empty(const struct plist_node *node)
5841 return plist_head_empty(&node->plist);
5843 # 234 "include/linux/plist.h"
5844 static inline __attribute__((always_inline)) struct plist_node* plist_first(const struct plist_head *head)
5846 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) );});
5849 # 17 "include/linux/rtmutex.h" 2
5850 # 26 "include/linux/rtmutex.h"
5852 spinlock_t wait_lock;
5853 struct plist_head wait_list;
5854 struct task_struct *owner;
5863 struct rt_mutex_waiter;
5864 struct hrtimer_sleeper;
5871 static inline __attribute__((always_inline)) int rt_mutex_debug_check_no_locks_freed(const void *from,
5876 # 80 "include/linux/rtmutex.h"
5877 static inline __attribute__((always_inline)) int rt_mutex_is_locked(struct rt_mutex *lock)
5879 return lock->owner != ((void *)0);
5882 extern void __rt_mutex_init(struct rt_mutex *lock, const char *name);
5883 extern void rt_mutex_destroy(struct rt_mutex *lock);
5885 extern void rt_mutex_lock(struct rt_mutex *lock);
5886 extern int rt_mutex_lock_interruptible(struct rt_mutex *lock,
5887 int detect_deadlock);
5888 extern int rt_mutex_timed_lock(struct rt_mutex *lock,
5889 struct hrtimer_sleeper *timeout,
5890 int detect_deadlock);
5892 extern int rt_mutex_trylock(struct rt_mutex *lock);
5894 extern void rt_mutex_unlock(struct rt_mutex *lock);
5895 # 79 "include/linux/sched.h" 2
5898 # 1 "include/linux/param.h" 1
5899 # 82 "include/linux/sched.h" 2
5900 # 1 "include/linux/resource.h" 1
5907 # 23 "include/linux/resource.h"
5909 struct timeval ru_utime;
5910 struct timeval ru_stime;
5928 unsigned long rlim_cur;
5929 unsigned long rlim_max;
5931 # 70 "include/linux/resource.h"
5932 # 1 "include/asm/resource.h" 1
5936 # 1 "include/asm-generic/resource.h" 1
5937 # 5 "include/asm/resource.h" 2
5938 # 71 "include/linux/resource.h" 2
5940 int getrusage(struct task_struct *p, int who, struct rusage *ru);
5941 # 83 "include/linux/sched.h" 2
5942 # 1 "include/linux/timer.h" 1
5947 # 1 "include/linux/ktime.h" 1
5948 # 46 "include/linux/ktime.h"
5961 # 142 "include/linux/ktime.h"
5962 static inline __attribute__((always_inline)) ktime_t ktime_set(const long secs, const unsigned long nsecs)
5964 return (ktime_t) { .tv = { .sec = secs, .nsec = nsecs } };
5966 # 154 "include/linux/ktime.h"
5967 static inline __attribute__((always_inline)) ktime_t ktime_sub(const ktime_t lhs, const ktime_t rhs)
5971 res.tv64 = lhs.tv64 - rhs.tv64;
5972 if (res.tv.nsec < 0)
5973 res.tv.nsec += 1000000000L;
5977 # 172 "include/linux/ktime.h"
5978 static inline __attribute__((always_inline)) ktime_t ktime_add(const ktime_t add1, const ktime_t add2)
5982 res.tv64 = add1.tv64 + add2.tv64;
5983 # 185 "include/linux/ktime.h"
5984 if (res.tv.nsec >= 1000000000L)
5985 res.tv64 += (u32)-1000000000L;
5989 # 198 "include/linux/ktime.h"
5990 extern ktime_t ktime_add_ns(const ktime_t kt, u64 nsec);
5998 static inline __attribute__((always_inline)) ktime_t timespec_to_ktime(const struct timespec ts)
6000 return (ktime_t) { .tv = { .sec = (s32)ts.tv_sec,
6001 .nsec = (s32)ts.tv_nsec } };
6010 static inline __attribute__((always_inline)) ktime_t timeval_to_ktime(const struct timeval tv)
6012 return (ktime_t) { .tv = { .sec = (s32)tv.tv_sec,
6013 .nsec = (s32)tv.tv_usec * 1000 } };
6022 static inline __attribute__((always_inline)) struct timespec ktime_to_timespec(const ktime_t kt)
6024 return (struct timespec) { .tv_sec = (time_t) kt.tv.sec,
6025 .tv_nsec = (long) kt.tv.nsec };
6034 static inline __attribute__((always_inline)) struct timeval ktime_to_timeval(const ktime_t kt)
6036 return (struct timeval) {
6037 .tv_sec = (time_t) kt.tv.sec,
6038 .tv_usec = (suseconds_t) (kt.tv.nsec / 1000L) };
6047 static inline __attribute__((always_inline)) s64 ktime_to_ns(const ktime_t kt)
6049 return (s64) kt.tv.sec * 1000000000L + kt.tv.nsec;
6051 # 271 "include/linux/ktime.h"
6052 extern void ktime_get_ts(struct timespec *ts);
6053 # 6 "include/linux/timer.h" 2
6057 struct tvec_t_base_s;
6060 struct list_head entry;
6061 unsigned long expires;
6063 void (*function)(unsigned long);
6066 struct tvec_t_base_s *base;
6074 extern struct tvec_t_base_s boot_tvec_bases;
6075 # 39 "include/linux/timer.h"
6076 void init_timer(struct timer_list * timer);
6078 static inline __attribute__((always_inline)) void setup_timer(struct timer_list * timer,
6079 void (*function)(unsigned long),
6082 timer->function = function;
6086 # 60 "include/linux/timer.h"
6087 static inline __attribute__((always_inline)) int timer_pending(const struct timer_list * timer)
6089 return timer->entry.next != ((void *)0);
6092 extern void add_timer_on(struct timer_list *timer, int cpu);
6093 extern int del_timer(struct timer_list * timer);
6094 extern int __mod_timer(struct timer_list *timer, unsigned long expires);
6095 extern int mod_timer(struct timer_list *timer, unsigned long expires);
6101 extern unsigned long next_timer_interrupt(void);
6107 extern unsigned long get_next_timer_interrupt(unsigned long now);
6108 # 111 "include/linux/timer.h"
6109 static inline __attribute__((always_inline)) void init_timer_stats(void)
6113 static inline __attribute__((always_inline)) void timer_stats_account_timer(struct timer_list *timer)
6117 static inline __attribute__((always_inline)) void timer_stats_timer_set_start_info(struct timer_list *timer)
6121 static inline __attribute__((always_inline)) void timer_stats_timer_clear_start_info(struct timer_list *timer)
6126 extern void delayed_work_timer_fn(unsigned long __data);
6127 # 144 "include/linux/timer.h"
6128 static inline __attribute__((always_inline)) void add_timer(struct timer_list *timer)
6130 do { if (__builtin_expect(!!((timer_pending(timer))!=0), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/timer.h", 146, (__func__)); panic("BUG!"); } while (0); } while(0);
6131 __mod_timer(timer, timer->expires);
6133 # 160 "include/linux/timer.h"
6134 extern void init_timers(void);
6135 extern void run_local_timers(void);
6137 extern enum hrtimer_restart it_real_fn(struct hrtimer *);
6139 unsigned long __round_jiffies(unsigned long j, int cpu);
6140 unsigned long __round_jiffies_relative(unsigned long j, int cpu);
6141 unsigned long round_jiffies(unsigned long j);
6142 unsigned long round_jiffies_relative(unsigned long j);
6143 # 84 "include/linux/sched.h" 2
6144 # 1 "include/linux/hrtimer.h" 1
6145 # 24 "include/linux/hrtimer.h"
6146 struct hrtimer_clock_base;
6147 struct hrtimer_cpu_base;
6160 enum hrtimer_restart {
6164 # 53 "include/linux/hrtimer.h"
6165 enum hrtimer_cb_mode {
6168 HRTIMER_CB_IRQSAFE_NO_RESTART,
6169 HRTIMER_CB_IRQSAFE_NO_SOFTIRQ,
6171 # 112 "include/linux/hrtimer.h"
6173 struct rb_node node;
6175 enum hrtimer_restart (*function)(struct hrtimer *);
6176 struct hrtimer_clock_base *base;
6177 unsigned long state;
6178 # 127 "include/linux/hrtimer.h"
6180 # 136 "include/linux/hrtimer.h"
6181 struct hrtimer_sleeper {
6182 struct hrtimer timer;
6183 struct task_struct *task;
6185 # 156 "include/linux/hrtimer.h"
6186 struct hrtimer_clock_base {
6187 struct hrtimer_cpu_base *cpu_base;
6189 struct rb_root active;
6190 struct rb_node *first;
6192 ktime_t (*get_time)(void);
6193 ktime_t (*get_softirq_time)(void);
6194 ktime_t softirq_time;
6202 # 193 "include/linux/hrtimer.h"
6203 struct hrtimer_cpu_base {
6205 struct lock_class_key lock_key;
6206 struct hrtimer_clock_base clock_base[2];
6214 # 238 "include/linux/hrtimer.h"
6215 static inline __attribute__((always_inline)) void clock_was_set(void) { }
6217 static inline __attribute__((always_inline)) void hres_timers_resume(void) { }
6223 static inline __attribute__((always_inline)) ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
6225 return timer->base->softirq_time;
6230 extern ktime_t ktime_get(void);
6231 extern ktime_t ktime_get_real(void);
6236 extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
6237 enum hrtimer_mode mode);
6240 extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
6241 const enum hrtimer_mode mode);
6242 extern int hrtimer_cancel(struct hrtimer *timer);
6243 extern int hrtimer_try_to_cancel(struct hrtimer *timer);
6245 static inline __attribute__((always_inline)) int hrtimer_restart(struct hrtimer *timer)
6247 return hrtimer_start(timer, timer->expires, HRTIMER_MODE_ABS);
6251 extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
6252 extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
6254 extern ktime_t hrtimer_get_next_event(void);
6260 static inline __attribute__((always_inline)) int hrtimer_active(const struct hrtimer *timer)
6262 return timer->state != 0x00;
6268 static inline __attribute__((always_inline)) int hrtimer_is_queued(struct hrtimer *timer)
6270 return timer->state &
6275 extern unsigned long
6276 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
6279 extern long hrtimer_nanosleep(struct timespec *rqtp,
6280 struct timespec *rmtp,
6281 const enum hrtimer_mode mode,
6282 const clockid_t clockid);
6283 extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);
6285 extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
6286 struct task_struct *tsk);
6289 extern void hrtimer_run_queues(void);
6292 extern void __attribute__ ((__section__ (".init.text"))) hrtimers_init(void);
6295 extern unsigned long ktime_divns(const ktime_t kt, s64 div);
6301 extern void sysrq_timer_list_show(void);
6302 # 353 "include/linux/hrtimer.h"
6303 static inline __attribute__((always_inline)) void timer_stats_account_hrtimer(struct hrtimer *timer)
6307 static inline __attribute__((always_inline)) void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
6311 static inline __attribute__((always_inline)) void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
6314 # 85 "include/linux/sched.h" 2
6315 # 1 "include/linux/task_io_accounting.h" 1
6316 # 35 "include/linux/task_io_accounting.h"
6317 struct task_io_accounting {
6319 # 86 "include/linux/sched.h" 2
6324 struct futex_pi_state;
6325 # 108 "include/linux/sched.h"
6326 extern unsigned long avenrun[];
6327 # 122 "include/linux/sched.h"
6328 extern unsigned long total_forks;
6329 extern int nr_threads;
6330 extern __typeof__(unsigned long) per_cpu__process_counts;
6331 extern int nr_processes(void);
6332 extern unsigned long nr_running(void);
6333 extern unsigned long nr_uninterruptible(void);
6334 extern unsigned long nr_active(void);
6335 extern unsigned long nr_iowait(void);
6336 extern unsigned long weighted_cpuload(const int cpu);
6337 # 187 "include/linux/sched.h"
6338 extern rwlock_t tasklist_lock;
6339 extern spinlock_t mmlist_lock;
6343 extern void sched_init(void);
6344 extern void sched_init_smp(void);
6345 extern void init_idle(struct task_struct *idle, int cpu);
6347 extern cpumask_t nohz_cpu_mask;
6352 extern void show_state_filter(unsigned long state_filter);
6354 static inline __attribute__((always_inline)) void show_state(void)
6356 show_state_filter(-1);
6359 extern void show_regs(struct pt_regs *);
6366 extern void show_stack(struct task_struct *task, unsigned long *sp);
6368 void io_schedule(void);
6369 long io_schedule_timeout(long timeout);
6371 extern void cpu_init (void);
6372 extern void trap_init(void);
6373 extern void update_process_times(int user);
6374 extern void scheduler_tick(void);
6381 static inline __attribute__((always_inline)) void softlockup_tick(void)
6384 static inline __attribute__((always_inline)) void spawn_softlockup_task(void)
6387 static inline __attribute__((always_inline)) void touch_softlockup_watchdog(void)
6396 extern int in_sched_functions(unsigned long addr);
6399 extern signed long schedule_timeout(signed long timeout);
6400 extern signed long schedule_timeout_interruptible(signed long timeout);
6401 extern signed long schedule_timeout_uninterruptible(signed long timeout);
6402 void schedule(void);
6409 extern int sysctl_max_map_count;
6411 # 1 "include/linux/aio.h" 1
6416 # 1 "include/linux/workqueue.h" 1
6417 # 13 "include/linux/workqueue.h"
6418 struct workqueue_struct;
6421 typedef void (*work_func_t)(struct work_struct *work);
6429 struct work_struct {
6435 struct list_head entry;
6442 struct delayed_work {
6443 struct work_struct work;
6444 struct timer_list timer;
6447 struct execute_work {
6448 struct work_struct work;
6450 # 161 "include/linux/workqueue.h"
6451 extern struct workqueue_struct *__create_workqueue(const char *name,
6458 extern void destroy_workqueue(struct workqueue_struct *wq);
6460 extern int queue_work(struct workqueue_struct *wq, struct work_struct *work);
6461 extern int queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay);
6462 extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
6463 struct delayed_work *work, unsigned long delay);
6464 extern void flush_workqueue(struct workqueue_struct *wq);
6466 extern int schedule_work(struct work_struct *work);
6467 extern int run_scheduled_work(struct work_struct *work);
6468 extern int schedule_delayed_work(struct delayed_work *work, unsigned long delay);
6470 extern int schedule_delayed_work_on(int cpu, struct delayed_work *work, unsigned long delay);
6471 extern int schedule_on_each_cpu(work_func_t func);
6472 extern void flush_scheduled_work(void);
6473 extern int current_is_keventd(void);
6474 extern int keventd_up(void);
6476 extern void init_workqueues(void);
6477 void cancel_rearming_delayed_work(struct delayed_work *work);
6478 void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
6479 struct delayed_work *);
6480 int execute_in_process_context(work_func_t fn, struct execute_work *);
6487 static inline __attribute__((always_inline)) int cancel_delayed_work(struct delayed_work *work)
6491 ret = del_timer(&work->timer);
6493 clear_bit(0, ((unsigned long *)(&(&work->work)->data)));
6496 # 6 "include/linux/aio.h" 2
6497 # 1 "include/linux/aio_abi.h" 1
6498 # 32 "include/linux/aio_abi.h"
6499 typedef unsigned long aio_context_t;
6503 IOCB_CMD_PWRITE = 1,
6505 IOCB_CMD_FDSYNC = 3,
6511 IOCB_CMD_PREADV = 7,
6512 IOCB_CMD_PWRITEV = 8,
6522 # 70 "include/linux/aio_abi.h"
6526 __u32 aio_key, aio_reserved1;
6530 __u16 aio_lio_opcode;
6539 __u64 aio_reserved2;
6540 __u64 aio_reserved3;
6542 # 7 "include/linux/aio.h" 2
6543 # 1 "include/linux/uio.h" 1
6544 # 20 "include/linux/uio.h"
6548 __kernel_size_t iov_len;
6557 # 54 "include/linux/uio.h"
6558 static inline __attribute__((always_inline)) size_t iov_length(const struct iovec *iov, unsigned long nr_segs)
6563 for (seg = 0; seg < nr_segs; seg++)
6564 ret += iov[seg].iov_len;
6568 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to);
6569 # 8 "include/linux/aio.h" 2
6578 # 87 "include/linux/aio.h"
6580 struct list_head ki_run_list;
6585 struct file *ki_filp;
6586 struct kioctx *ki_ctx;
6587 int (*ki_cancel)(struct kiocb *, struct io_event *);
6588 ssize_t (*ki_retry)(struct kiocb *);
6589 void (*ki_dtor)(struct kiocb *);
6593 struct task_struct *tsk;
6597 wait_queue_t ki_wait;
6600 atomic_t ki_bio_count;
6603 unsigned short ki_opcode;
6607 struct iovec ki_inline_vec;
6608 struct iovec *ki_iovec;
6609 unsigned long ki_nr_segs;
6610 unsigned long ki_cur_seg;
6612 struct list_head ki_list;
6615 # 144 "include/linux/aio.h"
6623 unsigned compat_features;
6624 unsigned incompat_features;
6625 unsigned header_length;
6628 struct io_event io_events[0];
6634 struct aio_ring_info {
6635 unsigned long mmap_base;
6636 unsigned long mmap_size;
6638 struct page **ring_pages;
6639 spinlock_t ring_lock;
6644 struct page *internal_pages[8];
6650 struct mm_struct *mm;
6653 unsigned long user_id;
6654 struct kioctx *next;
6656 wait_queue_head_t wait;
6658 spinlock_t ctx_lock;
6661 struct list_head active_reqs;
6662 struct list_head run_list;
6667 struct aio_ring_info ring_info;
6669 struct delayed_work wq;
6673 extern unsigned aio_max_size;
6675 extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb);
6676 extern int aio_put_req(struct kiocb *iocb);
6677 extern void kick_iocb(struct kiocb *iocb);
6678 extern int aio_complete(struct kiocb *iocb, long res, long res2);
6679 extern void __put_ioctx(struct kioctx *ctx);
6681 extern void exit_aio(struct mm_struct *mm);
6682 extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
6683 extern int io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, struct iocb *iocb);
6687 struct kioctx *lookup_ioctx(unsigned long ctx_id);
6688 int io_submit_one(struct kioctx *ctx, struct iocb *user_iocb, struct iocb *iocb);
6689 # 244 "include/linux/aio.h"
6690 static inline __attribute__((always_inline)) struct kiocb *list_kiocb(struct list_head *h)
6692 return ({ const typeof( ((struct kiocb *)0)->ki_list ) *__mptr = (h); (struct kiocb *)( (char *)__mptr - __builtin_offsetof(struct kiocb,ki_list) );});
6696 extern unsigned long aio_nr;
6697 extern unsigned long aio_max_nr;
6698 # 261 "include/linux/sched.h" 2
6700 extern unsigned long
6701 arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
6702 unsigned long, unsigned long);
6703 extern unsigned long
6704 arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
6705 unsigned long len, unsigned long pgoff,
6706 unsigned long flags);
6707 extern void arch_unmap_area(struct mm_struct *, unsigned long);
6708 extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
6709 # 294 "include/linux/sched.h"
6710 typedef unsigned long mm_counter_t;
6711 # 310 "include/linux/sched.h"
6713 struct vm_area_struct * mmap;
6714 struct rb_root mm_rb;
6715 struct vm_area_struct * mmap_cache;
6716 unsigned long (*get_unmapped_area) (struct file *filp,
6717 unsigned long addr, unsigned long len,
6718 unsigned long pgoff, unsigned long flags);
6719 void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
6720 unsigned long mmap_base;
6721 unsigned long task_size;
6722 unsigned long cached_hole_size;
6723 unsigned long free_area_cache;
6728 struct rw_semaphore mmap_sem;
6729 spinlock_t page_table_lock;
6731 struct list_head mmlist;
6739 mm_counter_t _file_rss;
6740 mm_counter_t _anon_rss;
6742 unsigned long hiwater_rss;
6743 unsigned long hiwater_vm;
6745 unsigned long total_vm, locked_vm, shared_vm, exec_vm;
6746 unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
6747 unsigned long start_code, end_code, start_data, end_data;
6748 unsigned long start_brk, brk, start_stack;
6749 unsigned long arg_start, arg_end, env_start, env_end;
6751 unsigned long saved_auxv[44];
6753 cpumask_t cpu_vm_mask;
6756 mm_context_t context;
6757 # 363 "include/linux/sched.h"
6758 unsigned int faultstamp;
6759 unsigned int token_priority;
6760 unsigned int last_interval;
6762 unsigned char dumpable:2;
6766 struct completion *core_startup_done, core_done;
6769 rwlock_t ioctx_list_lock;
6770 struct kioctx *ioctx_list;
6773 struct sighand_struct {
6775 struct k_sigaction action[64];
6779 struct pacct_struct {
6782 unsigned long ac_mem;
6783 cputime_t ac_utime, ac_stime;
6784 unsigned long ac_minflt, ac_majflt;
6786 # 399 "include/linux/sched.h"
6787 struct signal_struct {
6791 wait_queue_head_t wait_chldexit;
6794 struct task_struct *curr_target;
6797 struct sigpending shared_pending;
6800 int group_exit_code;
6806 struct task_struct *group_exit_task;
6810 int group_stop_count;
6814 struct list_head posix_timers;
6817 struct hrtimer real_timer;
6818 struct task_struct *tsk;
6819 ktime_t it_real_incr;
6822 cputime_t it_prof_expires, it_virt_expires;
6823 cputime_t it_prof_incr, it_virt_incr;
6827 struct pid *tty_old_pgrp;
6830 pid_t session __attribute__((deprecated));
6837 struct tty_struct *tty;
6845 cputime_t utime, stime, cutime, cstime;
6846 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
6847 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
6855 unsigned long long sched_time;
6856 # 478 "include/linux/sched.h"
6857 struct rlimit rlim[15];
6859 struct list_head cpu_timers[3];
6860 # 494 "include/linux/sched.h"
6862 # 537 "include/linux/sched.h"
6863 struct user_struct {
6867 atomic_t sigpending;
6869 atomic_t inotify_watches;
6870 atomic_t inotify_devs;
6873 unsigned long mq_bytes;
6874 unsigned long locked_shm;
6882 struct list_head uidhash_list;
6886 extern struct user_struct *find_user(uid_t);
6888 extern struct user_struct root_user;
6891 struct backing_dev_info;
6892 struct reclaim_state;
6893 # 615 "include/linux/sched.h"
6894 static inline __attribute__((always_inline)) int sched_info_on(void)
6913 # 744 "include/linux/sched.h"
6922 gid_t small_block[32];
6926 # 772 "include/linux/sched.h"
6927 extern struct group_info *groups_alloc(int gidsetsize);
6928 extern void groups_free(struct group_info *group_info);
6929 extern int set_current_groups(struct group_info *group_info);
6930 extern int groups_search(struct group_info *group_info, gid_t grp);
6938 static inline __attribute__((always_inline)) void prefetch_stack(struct task_struct *t) { }
6941 struct audit_context;
6943 struct pipe_inode_info;
6944 struct uts_namespace;
6948 SLEEP_NONINTERACTIVE,
6955 struct task_struct {
6956 volatile long state;
6957 struct thread_info *thread_info;
6959 unsigned long flags;
6960 unsigned long ptrace;
6970 int prio, static_prio, normal_prio;
6971 struct list_head run_list;
6972 struct prio_array *array;
6974 unsigned short ioprio;
6978 unsigned long sleep_avg;
6979 unsigned long long timestamp, last_ran;
6980 unsigned long long sched_time;
6981 enum sleep_type sleep_type;
6983 unsigned long policy;
6984 cpumask_t cpus_allowed;
6985 unsigned int time_slice, first_time_slice;
6991 struct list_head tasks;
6996 struct list_head ptrace_children;
6997 struct list_head ptrace_list;
6999 struct mm_struct *mm, *active_mm;
7002 struct linux_binfmt *binfmt;
7004 int exit_code, exit_signal;
7007 unsigned long personality;
7008 unsigned did_exec:1;
7011 # 866 "include/linux/sched.h"
7012 struct task_struct *real_parent;
7013 struct task_struct *parent;
7018 struct list_head children;
7019 struct list_head sibling;
7020 struct task_struct *group_leader;
7023 struct pid_link pids[PIDTYPE_MAX];
7024 struct list_head thread_group;
7026 struct completion *vfork_done;
7028 int *clear_child_tid;
7030 unsigned long rt_priority;
7031 cputime_t utime, stime;
7032 unsigned long nvcsw, nivcsw;
7033 struct timespec start_time;
7035 unsigned long min_flt, maj_flt;
7037 cputime_t it_prof_expires, it_virt_expires;
7038 unsigned long long it_sched_expires;
7039 struct list_head cpu_timers[3];
7042 uid_t uid,euid,suid,fsuid;
7043 gid_t gid,egid,sgid,fsgid;
7044 struct group_info *group_info;
7045 kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
7046 unsigned keep_capabilities:1;
7047 struct user_struct *user;
7048 # 915 "include/linux/sched.h"
7049 unsigned char fpu_counter;
7056 int link_count, total_link_count;
7059 struct sysv_sem sysvsem;
7062 struct thread_struct thread;
7064 struct fs_struct *fs;
7066 struct files_struct *files;
7068 struct nsproxy *nsproxy;
7070 struct signal_struct *signal;
7071 struct sighand_struct *sighand;
7073 sigset_t blocked, real_blocked;
7074 sigset_t saved_sigmask;
7075 struct sigpending pending;
7077 unsigned long sas_ss_sp;
7079 int (*notifier)(void *priv);
7080 void *notifier_data;
7081 sigset_t *notifier_mask;
7084 struct audit_context *audit_context;
7091 spinlock_t alloc_lock;
7098 struct plist_head pi_waiters;
7100 struct rt_mutex_waiter *pi_blocked_on;
7101 # 997 "include/linux/sched.h"
7105 struct reclaim_state *reclaim_state;
7107 struct backing_dev_info *backing_dev_info;
7109 struct io_context *io_context;
7111 unsigned long ptrace_message;
7112 siginfo_t *last_siginfo;
7119 wait_queue_t *io_wait;
7124 struct task_io_accounting ioac;
7125 # 1035 "include/linux/sched.h"
7126 struct robust_list_head *robust_list;
7130 struct list_head pi_state_list;
7131 struct futex_pi_state *pi_state_cache;
7134 struct rcu_head rcu;
7139 struct pipe_inode_info *splice_pipe;
7148 static inline __attribute__((always_inline)) pid_t process_group(struct task_struct *tsk)
7150 return tsk->signal->pgrp;
7153 static inline __attribute__((always_inline)) pid_t signal_session(struct signal_struct *sig)
7155 return sig->__session;
7158 static inline __attribute__((always_inline)) pid_t process_session(struct task_struct *tsk)
7160 return signal_session(tsk->signal);
7163 static inline __attribute__((always_inline)) void set_signal_session(struct signal_struct *sig, pid_t session)
7165 sig->__session = session;
7168 static inline __attribute__((always_inline)) struct pid *task_pid(struct task_struct *task)
7170 return task->pids[PIDTYPE_PID].pid;
7173 static inline __attribute__((always_inline)) struct pid *task_tgid(struct task_struct *task)
7175 return task->group_leader->pids[PIDTYPE_PID].pid;
7178 static inline __attribute__((always_inline)) struct pid *task_pgrp(struct task_struct *task)
7180 return task->group_leader->pids[PIDTYPE_PGID].pid;
7183 static inline __attribute__((always_inline)) struct pid *task_session(struct task_struct *task)
7185 return task->group_leader->pids[PIDTYPE_SID].pid;
7187 # 1105 "include/linux/sched.h"
7188 static inline __attribute__((always_inline)) int pid_alive(struct task_struct *p)
7190 return p->pids[PIDTYPE_PID].pid != ((void *)0);
7199 static inline __attribute__((always_inline)) int is_init(struct task_struct *tsk)
7201 return tsk->pid == 1;
7204 extern struct pid *cad_pid;
7206 extern void free_task(struct task_struct *tsk);
7209 extern void __put_task_struct(struct task_struct *t);
7211 static inline __attribute__((always_inline)) void put_task_struct(struct task_struct *t)
7213 if ((atomic_sub_return(1, (&t->usage)) == 0))
7214 __put_task_struct(t);
7216 # 1190 "include/linux/sched.h"
7217 static inline __attribute__((always_inline)) int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
7219 if (!(__builtin_constant_p((0)) ? __constant_test_bit(((0)),((new_mask).bits)) : __test_bit(((0)),((new_mask).bits))))
7225 extern unsigned long long sched_clock(void);
7226 extern unsigned long long
7227 current_sched_time(const struct task_struct *current_task);
7228 # 1212 "include/linux/sched.h"
7229 static inline __attribute__((always_inline)) void idle_task_exit(void) {}
7232 extern void sched_idle_next(void);
7235 extern int rt_mutex_getprio(struct task_struct *p);
7236 extern void rt_mutex_setprio(struct task_struct *p, int prio);
7237 extern void rt_mutex_adjust_pi(struct task_struct *p);
7238 # 1229 "include/linux/sched.h"
7239 extern void set_user_nice(struct task_struct *p, long nice);
7240 extern int task_prio(const struct task_struct *p);
7241 extern int task_nice(const struct task_struct *p);
7242 extern int can_nice(const struct task_struct *p, const int nice);
7243 extern int task_curr(const struct task_struct *p);
7244 extern int idle_cpu(int cpu);
7245 extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
7246 extern struct task_struct *idle_task(int cpu);
7247 extern struct task_struct *curr_task(int cpu);
7248 extern void set_curr_task(int cpu, struct task_struct *p);
7255 extern struct exec_domain default_exec_domain;
7257 union thread_union {
7258 struct thread_info thread_info;
7259 unsigned long stack[8192/sizeof(long)];
7263 static inline __attribute__((always_inline)) int kstack_end(void *addr)
7268 return !(((unsigned long)addr+sizeof(void*)-1) & (8192 -sizeof(void*)));
7272 extern union thread_union init_thread_union;
7273 extern struct task_struct init_task;
7275 extern struct mm_struct init_mm;
7278 extern struct task_struct *find_task_by_pid_type(int type, int pid);
7279 extern void __set_special_pids(pid_t session, pid_t pgrp);
7282 extern struct user_struct * alloc_uid(uid_t);
7283 static inline __attribute__((always_inline)) struct user_struct *get_uid(struct user_struct *u)
7285 atomic_inc(&u->__count);
7288 extern void free_uid(struct user_struct *);
7289 extern void switch_uid(struct user_struct *);
7293 extern void do_timer(unsigned long ticks);
7295 extern int wake_up_state(struct task_struct * tsk, unsigned int state);
7296 extern int wake_up_process(struct task_struct * tsk);
7297 extern void wake_up_new_task(struct task_struct * tsk, unsigned long clone_flags);
7302 static inline __attribute__((always_inline)) void kick_process(struct task_struct *tsk) { }
7304 extern void sched_fork(struct task_struct * p, int clone_flags);
7305 extern void sched_exit(struct task_struct * p);
7307 extern int in_group_p(gid_t);
7308 extern int in_egroup_p(gid_t);
7310 extern void proc_caches_init(void);
7311 extern void flush_signals(struct task_struct *);
7312 extern void flush_signal_handlers(struct task_struct *, int force_default);
7313 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
7315 static inline __attribute__((always_inline)) int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
7317 unsigned long flags;
7320 do { do { __asm__ __volatile__ ( "cli %0;" :"=&d"(flags):); } while (0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (0); } while (0);
7321 ret = dequeue_signal(tsk, mask, info);
7322 do { do { if (((flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (0); } while (0);
7327 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
7329 extern void unblock_all_signals(void);
7330 extern void release_task(struct task_struct * p);
7331 extern int send_sig_info(int, struct siginfo *, struct task_struct *);
7332 extern int send_group_sig_info(int, struct siginfo *, struct task_struct *);
7333 extern int force_sigsegv(int, struct task_struct *);
7334 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
7335 extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
7336 extern int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
7337 extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
7338 extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
7339 extern int kill_pgrp(struct pid *pid, int sig, int priv);
7340 extern int kill_pid(struct pid *pid, int sig, int priv);
7341 extern int kill_proc_info(int, struct siginfo *, pid_t);
7342 extern void do_notify_parent(struct task_struct *, int);
7343 extern void force_sig(int, struct task_struct *);
7344 extern void force_sig_specific(int, struct task_struct *);
7345 extern int send_sig(int, struct task_struct *, int);
7346 extern void zap_other_threads(struct task_struct *p);
7347 extern int kill_proc(pid_t, int, int);
7348 extern struct sigqueue *sigqueue_alloc(void);
7349 extern void sigqueue_free(struct sigqueue *);
7350 extern int send_sigqueue(int, struct sigqueue *, struct task_struct *);
7351 extern int send_group_sigqueue(int, struct sigqueue *, struct task_struct *);
7352 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
7353 extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);
7355 static inline __attribute__((always_inline)) int kill_cad_pid(int sig, int priv)
7357 return kill_pid(cad_pid, sig, priv);
7365 static inline __attribute__((always_inline)) int is_si_special(const struct siginfo *info)
7367 return info <= ((struct siginfo *) 2);
7372 static inline __attribute__((always_inline)) int on_sig_stack(unsigned long sp)
7374 return (sp - (get_current())->sas_ss_sp < (get_current())->sas_ss_size);
7377 static inline __attribute__((always_inline)) int sas_ss_flags(unsigned long sp)
7379 return ((get_current())->sas_ss_size == 0 ? 2
7380 : on_sig_stack(sp) ? 1 : 0);
7386 extern struct mm_struct * mm_alloc(void);
7389 extern void __mmdrop(struct mm_struct *);
7390 static inline __attribute__((always_inline)) void mmdrop(struct mm_struct * mm)
7392 if ((atomic_sub_return(1, (&mm->mm_count)) == 0))
7397 extern void mmput(struct mm_struct *);
7399 extern struct mm_struct *get_task_mm(struct task_struct *task);
7401 extern void mm_release(struct task_struct *, struct mm_struct *);
7403 extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
7404 extern void flush_thread(void);
7405 extern void exit_thread(void);
7407 extern void exit_files(struct task_struct *);
7408 extern void __cleanup_signal(struct signal_struct *);
7409 extern void __cleanup_sighand(struct sighand_struct *);
7410 extern void exit_itimers(struct signal_struct *);
7412 extern void do_group_exit(int);
7414 extern void daemonize(const char *, ...);
7415 extern int allow_signal(int);
7416 extern int disallow_signal(int);
7418 extern int do_execve(char *, char * *, char * *, struct pt_regs *);
7419 extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int *, int *);
7420 struct task_struct *fork_idle(int);
7422 extern void set_task_comm(struct task_struct *tsk, char *from);
7423 extern void get_task_comm(char *to, struct task_struct *tsk);
7424 # 1448 "include/linux/sched.h"
7425 static inline __attribute__((always_inline)) int has_group_leader_pid(struct task_struct *p)
7427 return p->pid == p->tgid;
7430 static inline __attribute__((always_inline)) struct task_struct *next_thread(const struct task_struct *p)
7432 return ({ const typeof( ((struct task_struct *)0)->thread_group ) *__mptr = (({ typeof(p->thread_group.next) _________p1 = p->thread_group.next; do { } while(0); (_________p1); })); (struct task_struct *)( (char *)__mptr - __builtin_offsetof(struct task_struct,thread_group) );});
7436 static inline __attribute__((always_inline)) int thread_group_empty(struct task_struct *p)
7438 return list_empty(&p->thread_group);
7440 # 1476 "include/linux/sched.h"
7441 static inline __attribute__((always_inline)) void task_lock(struct task_struct *p)
7443 do { do { } while (0); (void)0; (void)(&p->alloc_lock); } while (0);
7446 static inline __attribute__((always_inline)) void task_unlock(struct task_struct *p)
7448 do { do { } while (0); (void)0; (void)(&p->alloc_lock); } while (0);
7451 extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
7452 unsigned long *flags);
7454 static inline __attribute__((always_inline)) void unlock_task_sighand(struct task_struct *tsk,
7455 unsigned long *flags)
7457 do { do { if (((*flags) != 0x1f)) do { __asm__ __volatile__ ( "sti %0;" ::"d"(irq_flags)); } while (0); } while (0); do { do { } while (0); (void)0; (void)(&tsk->sighand->siglock); } while (0); } while (0);
7465 static inline __attribute__((always_inline)) void setup_thread_stack(struct task_struct *p, struct task_struct *org)
7467 *(p)->thread_info = *(org)->thread_info;
7468 (p)->thread_info->task = p;
7471 static inline __attribute__((always_inline)) unsigned long *end_of_stack(struct task_struct *p)
7473 return (unsigned long *)(p->thread_info + 1);
7481 static inline __attribute__((always_inline)) void set_tsk_thread_flag(struct task_struct *tsk, int flag)
7483 set_ti_thread_flag((tsk)->thread_info, flag);
7486 static inline __attribute__((always_inline)) void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
7488 clear_ti_thread_flag((tsk)->thread_info, flag);
7491 static inline __attribute__((always_inline)) int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
7493 return test_and_set_ti_thread_flag((tsk)->thread_info, flag);
7496 static inline __attribute__((always_inline)) int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
7498 return test_and_clear_ti_thread_flag((tsk)->thread_info, flag);
7501 static inline __attribute__((always_inline)) int test_tsk_thread_flag(struct task_struct *tsk, int flag)
7503 return test_ti_thread_flag((tsk)->thread_info, flag);
7506 static inline __attribute__((always_inline)) void set_tsk_need_resched(struct task_struct *tsk)
7508 set_tsk_thread_flag(tsk,3);
7511 static inline __attribute__((always_inline)) void clear_tsk_need_resched(struct task_struct *tsk)
7513 clear_tsk_thread_flag(tsk,3);
7516 static inline __attribute__((always_inline)) int signal_pending(struct task_struct *p)
7518 return __builtin_expect(!!(test_tsk_thread_flag(p,2)), 0);
7521 static inline __attribute__((always_inline)) int need_resched(void)
7523 return __builtin_expect(!!(test_ti_thread_flag(current_thread_info(), 3)), 0);
7525 # 1568 "include/linux/sched.h"
7526 extern int cond_resched(void);
7527 extern int cond_resched_lock(spinlock_t * lock);
7528 extern int cond_resched_softirq(void);
7529 # 1586 "include/linux/sched.h"
7530 static inline __attribute__((always_inline)) int lock_need_resched(spinlock_t *lock)
7532 if (0 || need_resched())
7541 extern void recalc_sigpending_tsk(struct task_struct *t);
7542 extern void recalc_sigpending(void);
7544 extern void signal_wake_up(struct task_struct *t, int resume_stopped);
7545 # 1619 "include/linux/sched.h"
7546 static inline __attribute__((always_inline)) unsigned int task_cpu(const struct task_struct *p)
7551 static inline __attribute__((always_inline)) void set_task_cpu(struct task_struct *p, unsigned int cpu)
7560 static inline __attribute__((always_inline)) void arch_pick_mmap_layout(struct mm_struct *mm)
7563 mm->get_unmapped_area = arch_get_unmapped_area;
7564 mm->unmap_area = arch_unmap_area;
7568 extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
7569 extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
7571 # 1 "include/linux/sysdev.h" 1
7572 # 24 "include/linux/sysdev.h"
7573 # 1 "include/linux/kobject.h" 1
7574 # 22 "include/linux/kobject.h"
7575 # 1 "include/linux/sysfs.h" 1
7576 # 18 "include/linux/sysfs.h"
7584 struct module * owner;
7588 struct attribute_group {
7590 struct attribute ** attrs;
7592 # 56 "include/linux/sysfs.h"
7593 struct vm_area_struct;
7595 struct bin_attribute {
7596 struct attribute attr;
7599 ssize_t (*read)(struct kobject *, char *, loff_t, size_t);
7600 ssize_t (*write)(struct kobject *, char *, loff_t, size_t);
7601 int (*mmap)(struct kobject *, struct bin_attribute *attr,
7602 struct vm_area_struct *vma);
7606 ssize_t (*show)(struct kobject *, struct attribute *,char *);
7607 ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
7609 # 82 "include/linux/sysfs.h"
7610 extern int sysfs_schedule_callback(struct kobject *kobj,
7611 void (*func)(void *), void *data);
7613 extern int __attribute__((warn_unused_result))
7614 sysfs_create_dir(struct kobject *, struct dentry *);
7617 sysfs_remove_dir(struct kobject *);
7619 extern int __attribute__((warn_unused_result))
7620 sysfs_rename_dir(struct kobject *, struct dentry *, const char *new_name);
7622 extern int __attribute__((warn_unused_result))
7623 sysfs_move_dir(struct kobject *, struct kobject *);
7625 extern int __attribute__((warn_unused_result))
7626 sysfs_create_file(struct kobject *, const struct attribute *);
7628 extern int __attribute__((warn_unused_result))
7629 sysfs_update_file(struct kobject *, const struct attribute *);
7631 extern int __attribute__((warn_unused_result))
7632 sysfs_chmod_file(struct kobject *kobj, struct attribute *attr, mode_t mode);
7635 sysfs_remove_file(struct kobject *, const struct attribute *);
7637 extern int __attribute__((warn_unused_result))
7638 sysfs_create_link(struct kobject * kobj, struct kobject * target, const char * name);
7641 sysfs_remove_link(struct kobject *, const char * name);
7643 int __attribute__((warn_unused_result)) sysfs_create_bin_file(struct kobject *kobj,
7644 struct bin_attribute *attr);
7645 void sysfs_remove_bin_file(struct kobject *kobj, struct bin_attribute *attr);
7647 int __attribute__((warn_unused_result)) sysfs_create_group(struct kobject *,
7648 const struct attribute_group *);
7649 void sysfs_remove_group(struct kobject *, const struct attribute_group *);
7650 int sysfs_add_file_to_group(struct kobject *kobj,
7651 const struct attribute *attr, const char *group);
7652 void sysfs_remove_file_from_group(struct kobject *kobj,
7653 const struct attribute *attr, const char *group);
7655 void sysfs_notify(struct kobject * k, char *dir, char *attr);
7658 extern int sysfs_make_shadowed_dir(struct kobject *kobj,
7659 void * (*follow_link)(struct dentry *, struct nameidata *));
7660 extern struct dentry *sysfs_create_shadow_dir(struct kobject *kobj);
7661 extern void sysfs_remove_shadow_dir(struct dentry *dir);
7663 extern int __attribute__((warn_unused_result)) sysfs_init(void);
7664 # 23 "include/linux/kobject.h" 2
7665 # 35 "include/linux/kobject.h"
7666 extern char uevent_helper[];
7669 extern u64 uevent_seqnum;
7672 typedef int kobject_action_t;
7673 enum kobject_action {
7674 KOBJ_ADD = ( kobject_action_t) 0x01,
7675 KOBJ_REMOVE = ( kobject_action_t) 0x02,
7676 KOBJ_CHANGE = ( kobject_action_t) 0x03,
7677 KOBJ_MOUNT = ( kobject_action_t) 0x04,
7678 KOBJ_UMOUNT = ( kobject_action_t) 0x05,
7679 KOBJ_OFFLINE = ( kobject_action_t) 0x06,
7680 KOBJ_ONLINE = ( kobject_action_t) 0x07,
7681 KOBJ_MOVE = ( kobject_action_t) 0x08,
7685 const char * k_name;
7688 struct list_head entry;
7689 struct kobject * parent;
7691 struct kobj_type * ktype;
7692 struct dentry * dentry;
7693 wait_queue_head_t poll;
7696 extern int kobject_set_name(struct kobject *, const char *, ...)
7697 __attribute__((format(printf,2,3)));
7699 static inline __attribute__((always_inline)) const char * kobject_name(const struct kobject * kobj)
7701 return kobj->k_name;
7704 extern void kobject_init(struct kobject *);
7705 extern void kobject_cleanup(struct kobject *);
7707 extern int __attribute__((warn_unused_result)) kobject_add(struct kobject *);
7708 extern int __attribute__((warn_unused_result)) kobject_shadow_add(struct kobject *, struct dentry *);
7709 extern void kobject_del(struct kobject *);
7711 extern int __attribute__((warn_unused_result)) kobject_rename(struct kobject *, const char *new_name);
7712 extern int __attribute__((warn_unused_result)) kobject_shadow_rename(struct kobject *kobj,
7713 struct dentry *new_parent,
7714 const char *new_name);
7715 extern int __attribute__((warn_unused_result)) kobject_move(struct kobject *, struct kobject *);
7717 extern int __attribute__((warn_unused_result)) kobject_register(struct kobject *);
7718 extern void kobject_unregister(struct kobject *);
7720 extern struct kobject * kobject_get(struct kobject *);
7721 extern void kobject_put(struct kobject *);
7723 extern struct kobject *kobject_add_dir(struct kobject *, const char *);
7725 extern char * kobject_get_path(struct kobject *, gfp_t);
7728 void (*release)(struct kobject *);
7729 struct sysfs_ops * sysfs_ops;
7730 struct attribute ** default_attrs;
7732 # 120 "include/linux/kobject.h"
7733 struct kset_uevent_ops {
7734 int (*filter)(struct kset *kset, struct kobject *kobj);
7735 const char *(*name)(struct kset *kset, struct kobject *kobj);
7736 int (*uevent)(struct kset *kset, struct kobject *kobj, char **envp,
7737 int num_envp, char *buffer, int buffer_size);
7741 struct subsystem * subsys;
7742 struct kobj_type * ktype;
7743 struct list_head list;
7744 spinlock_t list_lock;
7745 struct kobject kobj;
7746 struct kset_uevent_ops * uevent_ops;
7750 extern void kset_init(struct kset * k);
7751 extern int __attribute__((warn_unused_result)) kset_add(struct kset * k);
7752 extern int __attribute__((warn_unused_result)) kset_register(struct kset * k);
7753 extern void kset_unregister(struct kset * k);
7755 static inline __attribute__((always_inline)) struct kset * to_kset(struct kobject * kobj)
7757 return kobj ? ({ const typeof( ((struct kset *)0)->kobj ) *__mptr = (kobj); (struct kset *)( (char *)__mptr - __builtin_offsetof(struct kset,kobj) );}) : ((void *)0);
7760 static inline __attribute__((always_inline)) struct kset * kset_get(struct kset * k)
7762 return k ? to_kset(kobject_get(&k->kobj)) : ((void *)0);
7765 static inline __attribute__((always_inline)) void kset_put(struct kset * k)
7767 kobject_put(&k->kobj);
7770 static inline __attribute__((always_inline)) struct kobj_type * get_ktype(struct kobject * k)
7772 if (k->kset && k->kset->ktype)
7773 return k->kset->ktype;
7778 extern struct kobject * kset_find_obj(struct kset *, const char *);
7779 # 176 "include/linux/kobject.h"
7782 struct rw_semaphore rwsem;
7784 # 199 "include/linux/kobject.h"
7785 extern struct subsystem kernel_subsys;
7787 extern struct subsystem hypervisor_subsys;
7788 # 248 "include/linux/kobject.h"
7789 extern void subsystem_init(struct subsystem *);
7790 extern int __attribute__((warn_unused_result)) subsystem_register(struct subsystem *);
7791 extern void subsystem_unregister(struct subsystem *);
7793 static inline __attribute__((always_inline)) struct subsystem * subsys_get(struct subsystem * s)
7795 return s ? ({ const typeof( ((struct subsystem *)0)->kset ) *__mptr = (kset_get(&s->kset)); (struct subsystem *)( (char *)__mptr - __builtin_offsetof(struct subsystem,kset) );}) : ((void *)0);
7798 static inline __attribute__((always_inline)) void subsys_put(struct subsystem * s)
7803 struct subsys_attribute {
7804 struct attribute attr;
7805 ssize_t (*show)(struct subsystem *, char *);
7806 ssize_t (*store)(struct subsystem *, const char *, size_t);
7809 extern int __attribute__((warn_unused_result)) subsys_create_file(struct subsystem * ,
7810 struct subsys_attribute *);
7813 int kobject_uevent(struct kobject *kobj, enum kobject_action action);
7814 int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
7817 int add_uevent_var(char **envp, int num_envp, int *cur_index,
7818 char *buffer, int buffer_size, int *cur_len,
7819 const char *format, ...)
7820 __attribute__((format (printf, 7, 8)));
7821 # 25 "include/linux/sysdev.h" 2
7822 # 1 "include/linux/pm.h" 1
7823 # 34 "include/linux/pm.h"
7824 typedef int pm_request_t;
7825 # 43 "include/linux/pm.h"
7826 typedef int pm_dev_t;
7827 # 56 "include/linux/pm.h"
7830 PM_SYS_UNKNOWN = 0x00000000,
7831 PM_SYS_KBC = 0x41d00303,
7832 PM_SYS_COM = 0x41d00500,
7833 PM_SYS_IRDA = 0x41d00510,
7834 PM_SYS_FDC = 0x41d00700,
7835 PM_SYS_VGA = 0x41d00900,
7836 PM_SYS_PCMCIA = 0x41d00e00,
7838 # 75 "include/linux/pm.h"
7841 typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);
7850 pm_callback callback;
7853 unsigned long flags;
7854 unsigned long state;
7855 unsigned long prev_state;
7857 struct list_head entry;
7866 extern void (*pm_idle)(void);
7867 extern void (*pm_power_off)(void);
7869 typedef int suspend_state_t;
7877 typedef int suspend_disk_method_t;
7878 # 152 "include/linux/pm.h"
7880 int (*valid)(suspend_state_t state);
7881 int (*prepare)(suspend_state_t state);
7882 int (*enter)(suspend_state_t state);
7883 int (*finish)(suspend_state_t state);
7884 suspend_disk_method_t pm_disk_mode;
7891 extern void pm_set_ops(struct pm_ops *pm_ops);
7892 extern struct pm_ops *pm_ops;
7893 extern int pm_suspend(suspend_state_t state);
7902 typedef struct pm_message {
7905 # 238 "include/linux/pm.h"
7906 struct dev_pm_info {
7907 pm_message_t power_state;
7908 unsigned can_wakeup:1;
7910 unsigned should_wakeup:1;
7911 pm_message_t prev_state;
7913 struct device * pm_parent;
7914 struct list_head entry;
7918 extern void device_pm_set_parent(struct device * dev, struct device * parent);
7920 extern int device_power_down(pm_message_t state);
7921 extern void device_power_up(void);
7922 extern void device_resume(void);
7925 extern suspend_disk_method_t pm_disk_mode;
7927 extern int device_suspend(pm_message_t state);
7928 extern int device_prepare_suspend(pm_message_t state);
7935 extern int dpm_runtime_suspend(struct device *, pm_message_t);
7936 extern void dpm_runtime_resume(struct device *);
7937 extern void __suspend_report_result(const char *function, void *fn, int ret);
7938 # 26 "include/linux/sysdev.h" 2
7943 struct sysdev_class {
7944 struct list_head drivers;
7947 int (*shutdown)(struct sys_device *);
7948 int (*suspend)(struct sys_device *, pm_message_t state);
7949 int (*resume)(struct sys_device *);
7953 struct sysdev_class_attribute {
7954 struct attribute attr;
7955 ssize_t (*show)(struct sysdev_class *, char *);
7956 ssize_t (*store)(struct sysdev_class *, const char *, size_t);
7958 # 54 "include/linux/sysdev.h"
7959 extern int sysdev_class_register(struct sysdev_class *);
7960 extern void sysdev_class_unregister(struct sysdev_class *);
7962 extern int sysdev_class_create_file(struct sysdev_class *,
7963 struct sysdev_class_attribute *);
7964 extern void sysdev_class_remove_file(struct sysdev_class *,
7965 struct sysdev_class_attribute *);
7970 struct sysdev_driver {
7971 struct list_head entry;
7972 int (*add)(struct sys_device *);
7973 int (*remove)(struct sys_device *);
7974 int (*shutdown)(struct sys_device *);
7975 int (*suspend)(struct sys_device *, pm_message_t state);
7976 int (*resume)(struct sys_device *);
7980 extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
7981 extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);
7991 struct sysdev_class * cls;
7992 struct kobject kobj;
7995 extern int sysdev_register(struct sys_device *);
7996 extern void sysdev_unregister(struct sys_device *);
7999 struct sysdev_attribute {
8000 struct attribute attr;
8001 ssize_t (*show)(struct sys_device *, char *);
8002 ssize_t (*store)(struct sys_device *, const char *, size_t);
8004 # 112 "include/linux/sysdev.h"
8005 extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
8006 extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
8007 # 1645 "include/linux/sched.h" 2
8008 extern int sched_mc_power_savings, sched_smt_power_savings;
8009 extern struct sysdev_attribute attr_sched_mc_power_savings, attr_sched_smt_power_savings;
8010 extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls);
8012 extern void normalize_rt_tasks(void);
8013 # 1672 "include/linux/sched.h"
8014 static inline __attribute__((always_inline)) void add_rchar(struct task_struct *tsk, ssize_t amt)
8018 static inline __attribute__((always_inline)) void add_wchar(struct task_struct *tsk, ssize_t amt)
8022 static inline __attribute__((always_inline)) void inc_syscr(struct task_struct *tsk)
8026 static inline __attribute__((always_inline)) void inc_syscw(struct task_struct *tsk)
8029 # 13 "include/asm/uaccess.h" 2
8030 # 1 "include/linux/mm.h" 1
8031 # 14 "include/linux/mm.h"
8032 # 1 "include/linux/prio_tree.h" 1
8033 # 14 "include/linux/prio_tree.h"
8034 struct raw_prio_tree_node {
8035 struct prio_tree_node *left;
8036 struct prio_tree_node *right;
8037 struct prio_tree_node *parent;
8040 struct prio_tree_node {
8041 struct prio_tree_node *left;
8042 struct prio_tree_node *right;
8043 struct prio_tree_node *parent;
8044 unsigned long start;
8048 struct prio_tree_root {
8049 struct prio_tree_node *prio_tree_node;
8050 unsigned short index_bits;
8058 struct prio_tree_iter {
8059 struct prio_tree_node *cur;
8061 unsigned long value;
8064 struct prio_tree_root *root;
8065 unsigned long r_index;
8066 unsigned long h_index;
8069 static inline __attribute__((always_inline)) void prio_tree_iter_init(struct prio_tree_iter *iter,
8070 struct prio_tree_root *root, unsigned long r_index, unsigned long h_index)
8073 iter->r_index = r_index;
8074 iter->h_index = h_index;
8075 iter->cur = ((void *)0);
8077 # 84 "include/linux/prio_tree.h"
8078 static inline __attribute__((always_inline)) int prio_tree_empty(const struct prio_tree_root *root)
8080 return root->prio_tree_node == ((void *)0);
8083 static inline __attribute__((always_inline)) int prio_tree_root(const struct prio_tree_node *node)
8085 return node->parent == node;
8088 static inline __attribute__((always_inline)) int prio_tree_left_empty(const struct prio_tree_node *node)
8090 return node->left == node;
8093 static inline __attribute__((always_inline)) int prio_tree_right_empty(const struct prio_tree_node *node)
8095 return node->right == node;
8099 struct prio_tree_node *prio_tree_replace(struct prio_tree_root *root,
8100 struct prio_tree_node *old, struct prio_tree_node *node);
8101 struct prio_tree_node *prio_tree_insert(struct prio_tree_root *root,
8102 struct prio_tree_node *node);
8103 void prio_tree_remove(struct prio_tree_root *root, struct prio_tree_node *node);
8104 struct prio_tree_node *prio_tree_next(struct prio_tree_iter *iter);
8105 # 15 "include/linux/mm.h" 2
8106 # 1 "include/linux/fs.h" 1
8107 # 9 "include/linux/fs.h"
8108 # 1 "include/linux/limits.h" 1
8109 # 10 "include/linux/fs.h" 2
8110 # 1 "include/linux/ioctl.h" 1
8114 # 1 "include/asm/ioctl.h" 1
8115 # 1 "include/asm-generic/ioctl.h" 1
8116 # 51 "include/asm-generic/ioctl.h"
8117 extern unsigned int __invalid_size_argument_for_IOC;
8118 # 1 "include/asm/ioctl.h" 2
8119 # 5 "include/linux/ioctl.h" 2
8120 # 11 "include/linux/fs.h" 2
8121 # 35 "include/linux/fs.h"
8122 struct files_stat_struct {
8127 extern struct files_stat_struct files_stat;
8128 extern int get_max_files(void);
8130 struct inodes_stat_t {
8135 extern struct inodes_stat_t inodes_stat;
8137 extern int leases_enable, lease_break_time;
8138 # 272 "include/linux/fs.h"
8139 # 1 "include/linux/kdev_t.h" 1
8140 # 21 "include/linux/kdev_t.h"
8141 static inline __attribute__((always_inline)) int old_valid_dev(dev_t dev)
8143 return ((unsigned int) ((dev) >> 20)) < 256 && ((unsigned int) ((dev) & ((1U << 20) - 1))) < 256;
8146 static inline __attribute__((always_inline)) u16 old_encode_dev(dev_t dev)
8148 return (((unsigned int) ((dev) >> 20)) << 8) | ((unsigned int) ((dev) & ((1U << 20) - 1)));
8151 static inline __attribute__((always_inline)) dev_t old_decode_dev(u16 val)
8153 return ((((val >> 8) & 255) << 20) | (val & 255));
8156 static inline __attribute__((always_inline)) int new_valid_dev(dev_t dev)
8161 static inline __attribute__((always_inline)) u32 new_encode_dev(dev_t dev)
8163 unsigned major = ((unsigned int) ((dev) >> 20));
8164 unsigned minor = ((unsigned int) ((dev) & ((1U << 20) - 1)));
8165 return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
8168 static inline __attribute__((always_inline)) dev_t new_decode_dev(u32 dev)
8170 unsigned major = (dev & 0xfff00) >> 8;
8171 unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
8172 return (((major) << 20) | (minor));
8175 static inline __attribute__((always_inline)) int huge_valid_dev(dev_t dev)
8180 static inline __attribute__((always_inline)) u64 huge_encode_dev(dev_t dev)
8182 return new_encode_dev(dev);
8185 static inline __attribute__((always_inline)) dev_t huge_decode_dev(u64 dev)
8187 return new_decode_dev(dev);
8190 static inline __attribute__((always_inline)) int sysv_valid_dev(dev_t dev)
8192 return ((unsigned int) ((dev) >> 20)) < (1<<14) && ((unsigned int) ((dev) & ((1U << 20) - 1))) < (1<<18);
8195 static inline __attribute__((always_inline)) u32 sysv_encode_dev(dev_t dev)
8197 return ((unsigned int) ((dev) & ((1U << 20) - 1))) | (((unsigned int) ((dev) >> 20)) << 18);
8200 static inline __attribute__((always_inline)) unsigned sysv_major(u32 dev)
8202 return (dev >> 18) & 0x3fff;
8205 static inline __attribute__((always_inline)) unsigned sysv_minor(u32 dev)
8207 return dev & 0x3ffff;
8209 # 273 "include/linux/fs.h" 2
8210 # 1 "include/linux/dcache.h" 1
8211 # 12 "include/linux/dcache.h"
8214 # 33 "include/linux/dcache.h"
8218 const unsigned char *name;
8221 struct dentry_stat_t {
8228 extern struct dentry_stat_t dentry_stat;
8235 static inline __attribute__((always_inline)) unsigned long
8236 partial_name_hash(unsigned long c, unsigned long prevhash)
8238 return (prevhash + (c << 4) + (c >> 4)) * 11;
8245 static inline __attribute__((always_inline)) unsigned long end_name_hash(unsigned long hash)
8247 return (unsigned int) hash;
8251 static inline __attribute__((always_inline)) unsigned int
8252 full_name_hash(const unsigned char *name, unsigned int len)
8254 unsigned long hash = 0;
8256 hash = partial_name_hash(*name++, hash);
8257 return end_name_hash(hash);
8260 struct dcookie_struct;
8266 unsigned int d_flags;
8268 struct inode *d_inode;
8274 struct hlist_node d_hash;
8275 struct dentry *d_parent;
8278 struct list_head d_lru;
8283 struct list_head d_child;
8284 struct rcu_head d_rcu;
8286 struct list_head d_subdirs;
8287 struct list_head d_alias;
8288 unsigned long d_time;
8289 struct dentry_operations *d_op;
8290 struct super_block *d_sb;
8296 unsigned char d_iname[36];
8305 enum dentry_d_lock_class
8307 DENTRY_D_LOCK_NORMAL,
8308 DENTRY_D_LOCK_NESTED
8311 struct dentry_operations {
8312 int (*d_revalidate)(struct dentry *, struct nameidata *);
8313 int (*d_hash) (struct dentry *, struct qstr *);
8314 int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
8315 int (*d_delete)(struct dentry *);
8316 void (*d_release)(struct dentry *);
8317 void (*d_iput)(struct dentry *, struct inode *);
8319 # 179 "include/linux/dcache.h"
8320 extern spinlock_t dcache_lock;
8321 # 197 "include/linux/dcache.h"
8322 static inline __attribute__((always_inline)) void __d_drop(struct dentry *dentry)
8324 if (!(dentry->d_flags & 0x0010)) {
8325 dentry->d_flags |= 0x0010;
8326 hlist_del_rcu(&dentry->d_hash);
8330 static inline __attribute__((always_inline)) void d_drop(struct dentry *dentry)
8332 do { do { } while (0); (void)0; (void)(&dcache_lock); } while (0);
8333 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
8335 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
8336 do { do { } while (0); (void)0; (void)(&dcache_lock); } while (0);
8339 static inline __attribute__((always_inline)) int dname_external(struct dentry *dentry)
8341 return dentry->d_name.name != dentry->d_iname;
8347 extern void d_instantiate(struct dentry *, struct inode *);
8348 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
8349 extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
8350 extern void d_delete(struct dentry *);
8353 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
8354 extern struct dentry * d_alloc_anon(struct inode *);
8355 extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
8356 extern void shrink_dcache_sb(struct super_block *);
8357 extern void shrink_dcache_parent(struct dentry *);
8358 extern void shrink_dcache_for_umount(struct super_block *);
8359 extern int d_invalidate(struct dentry *);
8362 extern struct dentry * d_alloc_root(struct inode *);
8365 extern void d_genocide(struct dentry *);
8367 extern struct dentry *d_find_alias(struct inode *);
8368 extern void d_prune_aliases(struct inode *);
8371 extern int have_submounts(struct dentry *);
8376 extern void d_rehash(struct dentry *);
8377 # 262 "include/linux/dcache.h"
8378 static inline __attribute__((always_inline)) void d_add(struct dentry *entry, struct inode *inode)
8380 d_instantiate(entry, inode);
8383 # 276 "include/linux/dcache.h"
8384 static inline __attribute__((always_inline)) struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
8388 res = d_instantiate_unique(entry, inode);
8389 d_rehash(res != ((void *)0) ? res : entry);
8394 extern void d_move(struct dentry *, struct dentry *);
8397 extern struct dentry * d_lookup(struct dentry *, struct qstr *);
8398 extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
8399 extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
8402 extern int d_validate(struct dentry *, struct dentry *);
8404 extern char * d_path(struct dentry *, struct vfsmount *, char *, int);
8405 # 313 "include/linux/dcache.h"
8406 static inline __attribute__((always_inline)) struct dentry *dget(struct dentry *dentry)
8409 do { if (__builtin_expect(!!((!((&dentry->d_count)->counter))!=0), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/dcache.h", 316, (__func__)); panic("BUG!"); } while (0); } while(0);
8410 atomic_inc(&dentry->d_count);
8415 extern struct dentry * dget_locked(struct dentry *);
8416 # 331 "include/linux/dcache.h"
8417 static inline __attribute__((always_inline)) int d_unhashed(struct dentry *dentry)
8419 return (dentry->d_flags & 0x0010);
8422 static inline __attribute__((always_inline)) struct dentry *dget_parent(struct dentry *dentry)
8426 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
8427 ret = dget(dentry->d_parent);
8428 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
8432 extern void dput(struct dentry *);
8434 static inline __attribute__((always_inline)) int d_mountpoint(struct dentry *dentry)
8436 return dentry->d_mounted;
8439 extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
8440 extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
8441 extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
8443 extern int sysctl_vfs_cache_pressure;
8444 # 274 "include/linux/fs.h" 2
8445 # 1 "include/linux/namei.h" 1
8454 struct open_intent {
8460 enum { MAX_NESTED_LINKS = 8 };
8463 struct dentry *dentry;
8464 struct vfsmount *mnt;
8469 char *saved_names[MAX_NESTED_LINKS + 1];
8473 struct open_intent open;
8478 struct vfsmount *mnt;
8479 struct dentry *dentry;
8485 enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
8486 # 65 "include/linux/namei.h"
8487 extern int __user_walk(const char *, unsigned, struct nameidata *);
8488 extern int __user_walk_fd(int dfd, const char *, unsigned, struct nameidata *);
8493 extern int path_lookup(const char *, unsigned, struct nameidata *);
8494 extern int path_walk(const char *, struct nameidata *);
8495 extern int link_path_walk(const char *, struct nameidata *);
8496 extern void path_release(struct nameidata *);
8497 extern void path_release_on_umount(struct nameidata *);
8499 extern int __user_path_lookup_open(const char *, unsigned lookup_flags, struct nameidata *nd, int open_flags);
8500 extern int path_lookup_open(int dfd, const char *name, unsigned lookup_flags, struct nameidata *, int open_flags);
8501 extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
8502 int (*open)(struct inode *, struct file *));
8503 extern struct file *nameidata_to_filp(struct nameidata *nd, int flags);
8504 extern void release_open_intent(struct nameidata *);
8506 extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
8508 extern int follow_down(struct vfsmount **, struct dentry **);
8509 extern int follow_up(struct vfsmount **, struct dentry **);
8511 extern struct dentry *lock_rename(struct dentry *, struct dentry *);
8512 extern void unlock_rename(struct dentry *, struct dentry *);
8514 static inline __attribute__((always_inline)) void nd_set_link(struct nameidata *nd, char *path)
8516 nd->saved_names[nd->depth] = path;
8519 static inline __attribute__((always_inline)) char *nd_get_link(struct nameidata *nd)
8521 return nd->saved_names[nd->depth];
8523 # 275 "include/linux/fs.h" 2
8524 # 1 "include/linux/stat.h" 1
8530 # 1 "include/asm/stat.h" 1
8535 unsigned short st_dev;
8536 unsigned short __pad1;
8537 unsigned long st_ino;
8538 unsigned short st_mode;
8539 unsigned short st_nlink;
8540 unsigned short st_uid;
8541 unsigned short st_gid;
8542 unsigned short st_rdev;
8543 unsigned short __pad2;
8544 unsigned long st_size;
8545 unsigned long st_blksize;
8546 unsigned long st_blocks;
8547 unsigned long st_atime;
8548 unsigned long __unused1;
8549 unsigned long st_mtime;
8550 unsigned long __unused2;
8551 unsigned long st_ctime;
8552 unsigned long __unused3;
8553 unsigned long __unused4;
8554 unsigned long __unused5;
8561 unsigned long long st_dev;
8562 unsigned char __pad1[4];
8565 unsigned long __st_ino;
8567 unsigned int st_mode;
8568 unsigned int st_nlink;
8570 unsigned long st_uid;
8571 unsigned long st_gid;
8573 unsigned long long st_rdev;
8574 unsigned char __pad2[4];
8577 unsigned long st_blksize;
8579 long long st_blocks;
8581 unsigned long st_atime;
8582 unsigned long st_atime_nsec;
8584 unsigned long st_mtime;
8585 unsigned long st_mtime_nsec;
8587 unsigned long st_ctime;
8588 unsigned long st_ctime_nsec;
8590 unsigned long long st_ino;
8592 # 7 "include/linux/stat.h" 2
8593 # 59 "include/linux/stat.h"
8603 struct timespec atime;
8604 struct timespec mtime;
8605 struct timespec ctime;
8606 unsigned long blksize;
8607 unsigned long long blocks;
8609 # 276 "include/linux/fs.h" 2
8613 # 1 "include/linux/radix-tree.h" 1
8614 # 38 "include/linux/radix-tree.h"
8615 static inline __attribute__((always_inline)) void *radix_tree_ptr_to_direct(void *ptr)
8617 return (void *)((unsigned long)ptr | 1);
8620 static inline __attribute__((always_inline)) void *radix_tree_direct_to_ptr(void *ptr)
8622 return (void *)((unsigned long)ptr & ~1);
8625 static inline __attribute__((always_inline)) int radix_tree_is_direct_ptr(void *ptr)
8627 return (int)((unsigned long)ptr & 1);
8635 struct radix_tree_root {
8636 unsigned int height;
8638 struct radix_tree_node *rnode;
8640 # 131 "include/linux/radix-tree.h"
8641 static inline __attribute__((always_inline)) void *radix_tree_deref_slot(void **pslot)
8643 return radix_tree_direct_to_ptr(*pslot);
8645 # 143 "include/linux/radix-tree.h"
8646 static inline __attribute__((always_inline)) void radix_tree_replace_slot(void **pslot, void *item)
8648 do { if (__builtin_expect(!!((radix_tree_is_direct_ptr(item))!=0), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/radix-tree.h", 145, (__func__)); panic("BUG!"); } while (0); } while(0);
8649 ({ __asm__ __volatile__("": : :"memory"); (*pslot) = ((void *)((unsigned long)item | ((unsigned long)*pslot & 1))); });
8654 int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
8655 void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
8656 void **radix_tree_lookup_slot(struct radix_tree_root *, unsigned long);
8657 void *radix_tree_delete(struct radix_tree_root *, unsigned long);
8659 radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
8660 unsigned long first_index, unsigned int max_items);
8661 int radix_tree_preload(gfp_t gfp_mask);
8662 void radix_tree_init(void);
8663 void *radix_tree_tag_set(struct radix_tree_root *root,
8664 unsigned long index, unsigned int tag);
8665 void *radix_tree_tag_clear(struct radix_tree_root *root,
8666 unsigned long index, unsigned int tag);
8667 int radix_tree_tag_get(struct radix_tree_root *root,
8668 unsigned long index, unsigned int tag);
8670 radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
8671 unsigned long first_index, unsigned int max_items,
8673 int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
8675 static inline __attribute__((always_inline)) void radix_tree_preload_end(void)
8679 # 280 "include/linux/fs.h" 2
8680 # 289 "include/linux/fs.h"
8685 struct pipe_inode_info;
8686 struct poll_table_struct;
8688 struct vm_area_struct;
8691 extern void __attribute__ ((__section__ (".init.text"))) inode_init(unsigned long);
8692 extern void __attribute__ ((__section__ (".init.text"))) inode_init_early(void);
8693 extern void __attribute__ ((__section__ (".init.text"))) mnt_init(unsigned long);
8694 extern void __attribute__ ((__section__ (".init.text"))) files_init(unsigned long);
8697 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
8698 struct buffer_head *bh_result, int create);
8699 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
8700 ssize_t bytes, void *private);
8701 # 338 "include/linux/fs.h"
8703 unsigned int ia_valid;
8708 struct timespec ia_atime;
8709 struct timespec ia_mtime;
8710 struct timespec ia_ctime;
8717 struct file *ia_file;
8723 # 1 "include/linux/quota.h" 1
8724 # 44 "include/linux/quota.h"
8725 typedef __kernel_uid32_t qid_t;
8726 typedef __u64 qsize_t;
8728 extern spinlock_t dq_data_lock;
8729 # 105 "include/linux/quota.h"
8731 __u64 dqb_bhardlimit;
8732 __u64 dqb_bsoftlimit;
8734 __u64 dqb_ihardlimit;
8735 __u64 dqb_isoftlimit;
8736 __u64 dqb_curinodes;
8741 # 126 "include/linux/quota.h"
8754 # 1 "include/linux/dqblk_xfs.h" 1
8755 # 50 "include/linux/dqblk_xfs.h"
8756 typedef struct fs_disk_quota {
8761 __u64 d_blk_hardlimit;
8762 __u64 d_blk_softlimit;
8763 __u64 d_ino_hardlimit;
8764 __u64 d_ino_softlimit;
8773 __u64 d_rtb_hardlimit;
8774 __u64 d_rtb_softlimit;
8781 # 137 "include/linux/dqblk_xfs.h"
8782 typedef struct fs_qfilestat {
8788 typedef struct fs_quota_stat {
8792 fs_qfilestat_t qs_uquota;
8793 fs_qfilestat_t qs_gquota;
8795 __s32 qs_btimelimit;
8796 __s32 qs_itimelimit;
8797 __s32 qs_rtbtimelimit;
8798 __u16 qs_bwarnlimit;
8799 __u16 qs_iwarnlimit;
8801 # 139 "include/linux/quota.h" 2
8802 # 1 "include/linux/dqblk_v1.h" 1
8803 # 21 "include/linux/dqblk_v1.h"
8804 struct v1_mem_dqinfo {
8806 # 140 "include/linux/quota.h" 2
8807 # 1 "include/linux/dqblk_v2.h" 1
8808 # 20 "include/linux/dqblk_v2.h"
8809 struct v2_mem_dqinfo {
8810 unsigned int dqi_blocks;
8811 unsigned int dqi_free_blk;
8812 unsigned int dqi_free_entry;
8814 # 141 "include/linux/quota.h" 2
8815 # 152 "include/linux/quota.h"
8817 __u32 dqb_bhardlimit;
8818 __u32 dqb_bsoftlimit;
8819 qsize_t dqb_curspace;
8820 __u32 dqb_ihardlimit;
8821 __u32 dqb_isoftlimit;
8822 __u32 dqb_curinodes;
8830 struct quota_format_type;
8833 struct quota_format_type *dqi_format;
8834 struct list_head dqi_dirty_list;
8835 unsigned long dqi_flags;
8836 unsigned int dqi_bgrace;
8837 unsigned int dqi_igrace;
8839 struct v1_mem_dqinfo v1_i;
8840 struct v2_mem_dqinfo v2_i;
8850 extern void mark_info_dirty(struct super_block *sb, int type);
8864 int allocated_dquots;
8869 extern struct dqstats dqstats;
8870 # 214 "include/linux/quota.h"
8872 struct hlist_node dq_hash;
8873 struct list_head dq_inuse;
8874 struct list_head dq_free;
8875 struct list_head dq_dirty;
8876 struct mutex dq_lock;
8878 wait_queue_head_t dq_wait_unused;
8879 struct super_block *dq_sb;
8882 unsigned long dq_flags;
8884 struct mem_dqblk dq_dqb;
8893 struct quota_format_ops {
8894 int (*check_quota_file)(struct super_block *sb, int type);
8895 int (*read_file_info)(struct super_block *sb, int type);
8896 int (*write_file_info)(struct super_block *sb, int type);
8897 int (*free_file_info)(struct super_block *sb, int type);
8898 int (*read_dqblk)(struct dquot *dquot);
8899 int (*commit_dqblk)(struct dquot *dquot);
8900 int (*release_dqblk)(struct dquot *dquot);
8904 struct dquot_operations {
8905 int (*initialize) (struct inode *, int);
8906 int (*drop) (struct inode *);
8907 int (*alloc_space) (struct inode *, qsize_t, int);
8908 int (*alloc_inode) (const struct inode *, unsigned long);
8909 int (*free_space) (struct inode *, qsize_t);
8910 int (*free_inode) (const struct inode *, unsigned long);
8911 int (*transfer) (struct inode *, struct iattr *);
8912 int (*write_dquot) (struct dquot *);
8913 int (*acquire_dquot) (struct dquot *);
8914 int (*release_dquot) (struct dquot *);
8915 int (*mark_dirty) (struct dquot *);
8916 int (*write_info) (struct super_block *, int);
8920 struct quotactl_ops {
8921 int (*quota_on)(struct super_block *, int, int, char *);
8922 int (*quota_off)(struct super_block *, int);
8923 int (*quota_sync)(struct super_block *, int);
8924 int (*get_info)(struct super_block *, int, struct if_dqinfo *);
8925 int (*set_info)(struct super_block *, int, struct if_dqinfo *);
8926 int (*get_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
8927 int (*set_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
8928 int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
8929 int (*set_xstate)(struct super_block *, unsigned int, int);
8930 int (*get_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
8931 int (*set_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
8934 struct quota_format_type {
8936 struct quota_format_ops *qf_ops;
8937 struct module *qf_owner;
8938 struct quota_format_type *qf_next;
8946 struct mutex dqio_mutex;
8947 struct mutex dqonoff_mutex;
8948 struct rw_semaphore dqptr_sem;
8949 struct inode *files[2];
8950 struct mem_dqinfo info[2];
8951 struct quota_format_ops *ops[2];
8955 int mark_dquot_dirty(struct dquot *dquot);
8956 # 308 "include/linux/quota.h"
8957 int register_quota_format(struct quota_format_type *fmt);
8958 void unregister_quota_format(struct quota_format_type *fmt);
8960 struct quota_module_name {
8964 # 360 "include/linux/fs.h" 2
8965 # 387 "include/linux/fs.h"
8966 enum positive_aop_returns {
8967 AOP_WRITEPAGE_ACTIVATE = 0x80000,
8968 AOP_TRUNCATED_PAGE = 0x80001,
8975 struct address_space;
8976 struct writeback_control;
8978 struct address_space_operations {
8979 int (*writepage)(struct page *page, struct writeback_control *wbc);
8980 int (*readpage)(struct file *, struct page *);
8981 void (*sync_page)(struct page *);
8984 int (*writepages)(struct address_space *, struct writeback_control *);
8987 int (*set_page_dirty)(struct page *page);
8989 int (*readpages)(struct file *filp, struct address_space *mapping,
8990 struct list_head *pages, unsigned nr_pages);
8996 int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
8997 int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
8999 sector_t (*bmap)(struct address_space *, sector_t);
9000 void (*invalidatepage) (struct page *, unsigned long);
9001 int (*releasepage) (struct page *, gfp_t);
9002 ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
9003 loff_t offset, unsigned long nr_segs);
9004 struct page* (*get_xip_page)(struct address_space *, sector_t,
9007 int (*migratepage) (struct address_space *,
9008 struct page *, struct page *);
9009 int (*launder_page) (struct page *);
9012 struct backing_dev_info;
9013 struct address_space {
9015 struct radix_tree_root page_tree;
9017 unsigned int i_mmap_writable;
9018 struct prio_tree_root i_mmap;
9019 struct list_head i_mmap_nonlinear;
9020 spinlock_t i_mmap_lock;
9021 unsigned int truncate_count;
9022 unsigned long nrpages;
9023 unsigned long writeback_index;
9024 const struct address_space_operations *a_ops;
9025 unsigned long flags;
9026 struct backing_dev_info *backing_dev_info;
9027 spinlock_t private_lock;
9028 struct list_head private_list;
9029 struct address_space *assoc_mapping;
9030 } __attribute__((aligned(sizeof(long))));
9037 struct block_device {
9039 struct inode * bd_inode;
9041 struct mutex bd_mutex;
9042 struct semaphore bd_mount_sem;
9043 struct list_head bd_inodes;
9047 struct list_head bd_holder_list;
9049 struct block_device * bd_contains;
9050 unsigned bd_block_size;
9051 struct hd_struct * bd_part;
9053 unsigned bd_part_count;
9055 struct gendisk * bd_disk;
9056 struct list_head bd_list;
9057 struct backing_dev_info *bd_inode_backing_dev_info;
9064 unsigned long bd_private;
9066 # 495 "include/linux/fs.h"
9067 int mapping_tagged(struct address_space *mapping, int tag);
9072 static inline __attribute__((always_inline)) int mapping_mapped(struct address_space *mapping)
9074 return !prio_tree_empty(&mapping->i_mmap) ||
9075 !list_empty(&mapping->i_mmap_nonlinear);
9084 static inline __attribute__((always_inline)) int mapping_writably_mapped(struct address_space *mapping)
9086 return mapping->i_mmap_writable != 0;
9088 # 528 "include/linux/fs.h"
9090 struct hlist_node i_hash;
9091 struct list_head i_list;
9092 struct list_head i_sb_list;
9093 struct list_head i_dentry;
9094 unsigned long i_ino;
9096 unsigned int i_nlink;
9100 unsigned long i_version;
9105 struct timespec i_atime;
9106 struct timespec i_mtime;
9107 struct timespec i_ctime;
9108 unsigned int i_blkbits;
9110 unsigned short i_bytes;
9113 struct mutex i_mutex;
9114 struct rw_semaphore i_alloc_sem;
9115 const struct inode_operations *i_op;
9116 const struct file_operations *i_fop;
9117 struct super_block *i_sb;
9118 struct file_lock *i_flock;
9119 struct address_space *i_mapping;
9120 struct address_space i_data;
9124 struct list_head i_devices;
9126 struct pipe_inode_info *i_pipe;
9127 struct block_device *i_bdev;
9128 struct cdev *i_cdev;
9140 struct list_head inotify_watches;
9141 struct mutex inotify_mutex;
9144 unsigned long i_state;
9145 unsigned long dirtied_when;
9147 unsigned int i_flags;
9149 atomic_t i_writecount;
9155 # 606 "include/linux/fs.h"
9156 enum inode_i_mutex_lock_class
9165 extern void inode_double_lock(struct inode *inode1, struct inode *inode2);
9166 extern void inode_double_unlock(struct inode *inode1, struct inode *inode2);
9167 # 628 "include/linux/fs.h"
9168 static inline __attribute__((always_inline)) loff_t i_size_read(const struct inode *inode)
9170 # 647 "include/linux/fs.h"
9171 return inode->i_size;
9180 static inline __attribute__((always_inline)) void i_size_write(struct inode *inode, loff_t i_size)
9182 # 667 "include/linux/fs.h"
9183 inode->i_size = i_size;
9187 static inline __attribute__((always_inline)) unsigned iminor(const struct inode *inode)
9189 return ((unsigned int) ((inode->i_rdev) & ((1U << 20) - 1)));
9192 static inline __attribute__((always_inline)) unsigned imajor(const struct inode *inode)
9194 return ((unsigned int) ((inode->i_rdev) >> 20));
9197 extern struct block_device *I_BDEV(struct inode *inode);
9199 struct fown_struct {
9202 enum pid_type pid_type;
9210 struct file_ra_state {
9211 unsigned long start;
9213 unsigned long flags;
9214 unsigned long cache_hit;
9215 unsigned long prev_page;
9216 unsigned long ahead_start;
9217 unsigned long ahead_size;
9218 unsigned long ra_pages;
9219 unsigned long mmap_hit;
9220 unsigned long mmap_miss;
9231 struct list_head fu_list;
9232 struct rcu_head fu_rcuhead;
9237 const struct file_operations *f_op;
9239 unsigned int f_flags;
9242 struct fown_struct f_owner;
9243 unsigned int f_uid, f_gid;
9244 struct file_ra_state f_ra;
9246 unsigned long f_version;
9258 struct address_space *f_mapping;
9260 extern spinlock_t files_lock;
9261 # 776 "include/linux/fs.h"
9262 typedef struct files_struct *fl_owner_t;
9264 struct file_lock_operations {
9265 void (*fl_insert)(struct file_lock *);
9266 void (*fl_remove)(struct file_lock *);
9267 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
9268 void (*fl_release_private)(struct file_lock *);
9271 struct lock_manager_operations {
9272 int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
9273 void (*fl_notify)(struct file_lock *);
9274 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
9275 void (*fl_release_private)(struct file_lock *);
9276 void (*fl_break)(struct file_lock *);
9277 int (*fl_mylease)(struct file_lock *, struct file_lock *);
9278 int (*fl_change)(struct file_lock **, int);
9282 # 1 "include/linux/nfs_fs_i.h" 1
9288 # 1 "include/linux/nfs.h" 1
9289 # 39 "include/linux/nfs.h"
9308 NFSERR_OPNOTSUPP = 45,
9309 NFSERR_NAMETOOLONG = 63,
9310 NFSERR_NOTEMPTY = 66,
9315 NFSERR_BADHANDLE = 10001,
9316 NFSERR_NOT_SYNC = 10002,
9317 NFSERR_BAD_COOKIE = 10003,
9318 NFSERR_NOTSUPP = 10004,
9319 NFSERR_TOOSMALL = 10005,
9320 NFSERR_SERVERFAULT = 10006,
9321 NFSERR_BADTYPE = 10007,
9322 NFSERR_JUKEBOX = 10008,
9323 NFSERR_SAME = 10009,
9324 NFSERR_DENIED = 10010,
9325 NFSERR_EXPIRED = 10011,
9326 NFSERR_LOCKED = 10012,
9327 NFSERR_GRACE = 10013,
9328 NFSERR_FHEXPIRED = 10014,
9329 NFSERR_SHARE_DENIED = 10015,
9330 NFSERR_WRONGSEC = 10016,
9331 NFSERR_CLID_INUSE = 10017,
9332 NFSERR_RESOURCE = 10018,
9333 NFSERR_MOVED = 10019,
9334 NFSERR_NOFILEHANDLE = 10020,
9335 NFSERR_MINOR_VERS_MISMATCH = 10021,
9336 NFSERR_STALE_CLIENTID = 10022,
9337 NFSERR_STALE_STATEID = 10023,
9338 NFSERR_OLD_STATEID = 10024,
9339 NFSERR_BAD_STATEID = 10025,
9340 NFSERR_BAD_SEQID = 10026,
9341 NFSERR_NOT_SAME = 10027,
9342 NFSERR_LOCK_RANGE = 10028,
9343 NFSERR_SYMLINK = 10029,
9344 NFSERR_RESTOREFH = 10030,
9345 NFSERR_LEASE_MOVED = 10031,
9346 NFSERR_ATTRNOTSUPP = 10032,
9347 NFSERR_NO_GRACE = 10033,
9348 NFSERR_RECLAIM_BAD = 10034,
9349 NFSERR_RECLAIM_CONFLICT = 10035,
9350 NFSERR_BAD_XDR = 10036,
9351 NFSERR_LOCKS_HELD = 10037,
9352 NFSERR_OPENMODE = 10038,
9353 NFSERR_BADOWNER = 10039,
9354 NFSERR_BADCHAR = 10040,
9355 NFSERR_BADNAME = 10041,
9356 NFSERR_BAD_RANGE = 10042,
9357 NFSERR_LOCK_NOTSUPP = 10043,
9358 NFSERR_OP_ILLEGAL = 10044,
9359 NFSERR_DEADLOCK = 10045,
9360 NFSERR_FILE_OPEN = 10046,
9361 NFSERR_ADMIN_REVOKED = 10047,
9362 NFSERR_CB_PATH_DOWN = 10048,
9363 NFSERR_REPLAY_ME = 10049
9381 # 1 "include/linux/sunrpc/msg_prot.h" 1
9382 # 18 "include/linux/sunrpc/msg_prot.h"
9383 typedef u32 rpc_authflavor_t;
9385 enum rpc_auth_flavors {
9392 RPC_AUTH_MAXFLAVOR = 8,
9394 RPC_AUTH_GSS_KRB5 = 390003,
9395 RPC_AUTH_GSS_KRB5I = 390004,
9396 RPC_AUTH_GSS_KRB5P = 390005,
9397 RPC_AUTH_GSS_LKEY = 390006,
9398 RPC_AUTH_GSS_LKEYI = 390007,
9399 RPC_AUTH_GSS_LKEYP = 390008,
9400 RPC_AUTH_GSS_SPKM = 390009,
9401 RPC_AUTH_GSS_SPKMI = 390010,
9402 RPC_AUTH_GSS_SPKMP = 390011,
9413 enum rpc_reply_stat {
9414 RPC_MSG_ACCEPTED = 0,
9418 enum rpc_accept_stat {
9420 RPC_PROG_UNAVAIL = 1,
9421 RPC_PROG_MISMATCH = 2,
9422 RPC_PROC_UNAVAIL = 3,
9423 RPC_GARBAGE_ARGS = 4,
9426 RPC_DROP_REPLY = 60000,
9429 enum rpc_reject_stat {
9434 enum rpc_auth_stat {
9436 RPC_AUTH_BADCRED = 1,
9437 RPC_AUTH_REJECTEDCRED = 2,
9438 RPC_AUTH_BADVERF = 3,
9439 RPC_AUTH_REJECTEDVERF = 4,
9440 RPC_AUTH_TOOWEAK = 5,
9442 RPCSEC_GSS_CREDPROBLEM = 13,
9443 RPCSEC_GSS_CTXPROBLEM = 14
9445 # 106 "include/linux/sunrpc/msg_prot.h"
9446 typedef __be32 rpc_fraghdr;
9447 # 131 "include/linux/nfs.h" 2
9455 unsigned short size;
9456 unsigned char data[128];
9463 static inline __attribute__((always_inline)) int nfs_compare_fh(const struct nfs_fh *a, const struct nfs_fh *b)
9465 return a->size != b->size || memcmp(a->data, b->data, a->size) != 0;
9468 static inline __attribute__((always_inline)) void nfs_copy_fh(struct nfs_fh *target, const struct nfs_fh *source)
9470 target->size = source->size;
9471 memcpy(target->data, source->data, source->size);
9473 # 165 "include/linux/nfs.h"
9474 enum nfs3_stable_how {
9479 # 7 "include/linux/nfs_fs_i.h" 2
9481 struct nlm_lockowner;
9486 struct nfs_lock_info {
9488 struct nlm_lockowner *owner;
9489 struct list_head list;
9492 struct nfs4_lock_state;
9493 struct nfs4_lock_info {
9494 struct nfs4_lock_state *owner;
9496 # 797 "include/linux/fs.h" 2
9499 struct file_lock *fl_next;
9500 struct list_head fl_link;
9501 struct list_head fl_block;
9502 fl_owner_t fl_owner;
9503 unsigned int fl_pid;
9504 wait_queue_head_t fl_wait;
9505 struct file *fl_file;
9506 unsigned char fl_flags;
9507 unsigned char fl_type;
9511 struct fasync_struct * fl_fasync;
9512 unsigned long fl_break_time;
9514 struct file_lock_operations *fl_ops;
9515 struct lock_manager_operations *fl_lmops;
9517 struct nfs_lock_info nfs_fl;
9518 struct nfs4_lock_info nfs4_fl;
9521 # 829 "include/linux/fs.h"
9522 # 1 "include/linux/fcntl.h" 1
9526 # 1 "include/asm/fcntl.h" 1
9527 # 11 "include/asm/fcntl.h"
9528 # 1 "include/asm-generic/fcntl.h" 1
9529 # 114 "include/asm-generic/fcntl.h"
9538 # 137 "include/asm-generic/fcntl.h"
9547 # 12 "include/asm/fcntl.h" 2
9548 # 5 "include/linux/fcntl.h" 2
9549 # 830 "include/linux/fs.h" 2
9551 extern int fcntl_getlk(struct file *, struct flock *);
9552 extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
9556 extern int fcntl_getlk64(struct file *, struct flock64 *);
9557 extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
9561 extern void send_sigio(struct fown_struct *fown, int fd, int band);
9562 extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
9563 extern int fcntl_getlease(struct file *filp);
9566 extern int do_sync_file_range(struct file *file, loff_t offset, loff_t endbyte,
9567 unsigned int flags);
9570 extern void locks_init_lock(struct file_lock *);
9571 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
9572 extern void locks_remove_posix(struct file *, fl_owner_t);
9573 extern void locks_remove_flock(struct file *);
9574 extern int posix_test_lock(struct file *, struct file_lock *, struct file_lock *);
9575 extern int posix_lock_file_conf(struct file *, struct file_lock *, struct file_lock *);
9576 extern int posix_lock_file(struct file *, struct file_lock *);
9577 extern int posix_lock_file_wait(struct file *, struct file_lock *);
9578 extern int posix_unblock_lock(struct file *, struct file_lock *);
9579 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
9580 extern int __break_lease(struct inode *inode, unsigned int flags);
9581 extern void lease_get_mtime(struct inode *, struct timespec *time);
9582 extern int setlease(struct file *, long, struct file_lock **);
9583 extern int lease_modify(struct file_lock **, int);
9584 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
9585 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
9587 struct fasync_struct {
9590 struct fasync_struct *fa_next;
9591 struct file *fa_file;
9597 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
9599 extern void kill_fasync(struct fasync_struct **, int, int);
9601 extern void __kill_fasync(struct fasync_struct *, int, int);
9603 extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
9604 extern int f_setown(struct file *filp, unsigned long arg, int force);
9605 extern void f_delown(struct file *filp);
9606 extern pid_t f_getown(struct file *filp);
9607 extern int send_sigurg(struct fown_struct *fown);
9608 # 897 "include/linux/fs.h"
9609 extern struct list_head super_blocks;
9610 extern spinlock_t sb_lock;
9614 struct super_block {
9615 struct list_head s_list;
9617 unsigned long s_blocksize;
9618 unsigned char s_blocksize_bits;
9619 unsigned char s_dirt;
9620 unsigned long long s_maxbytes;
9621 struct file_system_type *s_type;
9622 const struct super_operations *s_op;
9623 struct dquot_operations *dq_op;
9624 struct quotactl_ops *s_qcop;
9625 struct export_operations *s_export_op;
9626 unsigned long s_flags;
9627 unsigned long s_magic;
9628 struct dentry *s_root;
9629 struct rw_semaphore s_umount;
9630 struct mutex s_lock;
9638 struct xattr_handler **s_xattr;
9640 struct list_head s_inodes;
9641 struct list_head s_dirty;
9642 struct list_head s_io;
9643 struct hlist_head s_anon;
9644 struct list_head s_files;
9646 struct block_device *s_bdev;
9647 struct list_head s_instances;
9648 struct quota_info s_dquot;
9651 wait_queue_head_t s_wait_unfrozen;
9661 struct mutex s_vfs_rename_mutex;
9668 extern struct timespec current_fs_time(struct super_block *sb);
9675 SB_FREEZE_WRITE = 1,
9676 SB_FREEZE_TRANS = 2,
9678 # 975 "include/linux/fs.h"
9679 extern void lock_super(struct super_block *);
9680 extern void unlock_super(struct super_block *);
9685 extern int vfs_permission(struct nameidata *, int);
9686 extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
9687 extern int vfs_mkdir(struct inode *, struct dentry *, int);
9688 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
9689 extern int vfs_symlink(struct inode *, struct dentry *, const char *, int);
9690 extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
9691 extern int vfs_rmdir(struct inode *, struct dentry *);
9692 extern int vfs_unlink(struct inode *, struct dentry *);
9693 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
9698 extern void dentry_unhash(struct dentry *dentry);
9703 extern int file_permission(struct file *, int);
9704 # 1020 "include/linux/fs.h"
9705 int generic_osync_inode(struct inode *, struct address_space *, int);
9713 typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
9715 struct block_device_operations {
9716 int (*open) (struct inode *, struct file *);
9717 int (*release) (struct inode *, struct file *);
9718 int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
9719 long (*unlocked_ioctl) (struct file *, unsigned, unsigned long);
9720 long (*compat_ioctl) (struct file *, unsigned, unsigned long);
9721 int (*direct_access) (struct block_device *, sector_t, unsigned long *);
9722 int (*media_changed) (struct gendisk *);
9723 int (*revalidate_disk) (struct gendisk *);
9724 int (*getgeo)(struct block_device *, struct hd_geometry *);
9725 struct module *owner;
9727 # 1052 "include/linux/fs.h"
9736 } read_descriptor_t;
9738 typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
9739 # 1075 "include/linux/fs.h"
9740 struct file_operations {
9741 struct module *owner;
9742 loff_t (*llseek) (struct file *, loff_t, int);
9743 ssize_t (*read) (struct file *, char *, size_t, loff_t *);
9744 ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
9745 ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
9746 ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
9747 int (*readdir) (struct file *, void *, filldir_t);
9748 unsigned int (*poll) (struct file *, struct poll_table_struct *);
9749 int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
9750 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
9751 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
9752 int (*mmap) (struct file *, struct vm_area_struct *);
9753 int (*open) (struct inode *, struct file *);
9754 int (*flush) (struct file *, fl_owner_t id);
9755 int (*release) (struct inode *, struct file *);
9756 int (*fsync) (struct file *, struct dentry *, int datasync);
9757 int (*aio_fsync) (struct kiocb *, int datasync);
9758 int (*fasync) (int, struct file *, int);
9759 int (*lock) (struct file *, int, struct file_lock *);
9760 ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
9761 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
9762 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
9763 int (*check_flags)(int);
9764 int (*dir_notify)(struct file *filp, unsigned long arg);
9765 int (*flock) (struct file *, int, struct file_lock *);
9766 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
9767 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
9770 struct inode_operations {
9771 int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
9772 struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
9773 int (*link) (struct dentry *,struct inode *,struct dentry *);
9774 int (*unlink) (struct inode *,struct dentry *);
9775 int (*symlink) (struct inode *,struct dentry *,const char *);
9776 int (*mkdir) (struct inode *,struct dentry *,int);
9777 int (*rmdir) (struct inode *,struct dentry *);
9778 int (*mknod) (struct inode *,struct dentry *,int,dev_t);
9779 int (*rename) (struct inode *, struct dentry *,
9780 struct inode *, struct dentry *);
9781 int (*readlink) (struct dentry *, char *,int);
9782 void * (*follow_link) (struct dentry *, struct nameidata *);
9783 void (*put_link) (struct dentry *, struct nameidata *, void *);
9784 void (*truncate) (struct inode *);
9785 int (*permission) (struct inode *, int, struct nameidata *);
9786 int (*setattr) (struct dentry *, struct iattr *);
9787 int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
9788 int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
9789 ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
9790 ssize_t (*listxattr) (struct dentry *, char *, size_t);
9791 int (*removexattr) (struct dentry *, const char *);
9792 void (*truncate_range)(struct inode *, loff_t, loff_t);
9797 ssize_t rw_copy_check_uvector(int type, const struct iovec * uvector,
9798 unsigned long nr_segs, unsigned long fast_segs,
9799 struct iovec *fast_pointer,
9800 struct iovec **ret_pointer);
9802 extern ssize_t vfs_read(struct file *, char *, size_t, loff_t *);
9803 extern ssize_t vfs_write(struct file *, const char *, size_t, loff_t *);
9804 extern ssize_t vfs_readv(struct file *, const struct iovec *,
9805 unsigned long, loff_t *);
9806 extern ssize_t vfs_writev(struct file *, const struct iovec *,
9807 unsigned long, loff_t *);
9813 struct super_operations {
9814 struct inode *(*alloc_inode)(struct super_block *sb);
9815 void (*destroy_inode)(struct inode *);
9817 void (*read_inode) (struct inode *);
9819 void (*dirty_inode) (struct inode *);
9820 int (*write_inode) (struct inode *, int);
9821 void (*put_inode) (struct inode *);
9822 void (*drop_inode) (struct inode *);
9823 void (*delete_inode) (struct inode *);
9824 void (*put_super) (struct super_block *);
9825 void (*write_super) (struct super_block *);
9826 int (*sync_fs)(struct super_block *sb, int wait);
9827 void (*write_super_lockfs) (struct super_block *);
9828 void (*unlockfs) (struct super_block *);
9829 int (*statfs) (struct dentry *, struct kstatfs *);
9830 int (*remount_fs) (struct super_block *, int *, char *);
9831 void (*clear_inode) (struct inode *);
9832 void (*umount_begin) (struct vfsmount *, int);
9834 int (*show_options)(struct seq_file *, struct vfsmount *);
9835 int (*show_stats)(struct seq_file *, struct vfsmount *);
9841 # 1190 "include/linux/fs.h"
9842 extern void __mark_inode_dirty(struct inode *, int);
9843 static inline __attribute__((always_inline)) void mark_inode_dirty(struct inode *inode)
9845 __mark_inode_dirty(inode, (1 | 2 | 4));
9848 static inline __attribute__((always_inline)) void mark_inode_dirty_sync(struct inode *inode)
9850 __mark_inode_dirty(inode, 1);
9853 static inline __attribute__((always_inline)) void inc_nlink(struct inode *inode)
9858 static inline __attribute__((always_inline)) void inode_inc_link_count(struct inode *inode)
9861 mark_inode_dirty(inode);
9864 static inline __attribute__((always_inline)) void drop_nlink(struct inode *inode)
9869 static inline __attribute__((always_inline)) void clear_nlink(struct inode *inode)
9874 static inline __attribute__((always_inline)) void inode_dec_link_count(struct inode *inode)
9877 mark_inode_dirty(inode);
9880 extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
9881 static inline __attribute__((always_inline)) void file_accessed(struct file *file)
9883 if (!(file->f_flags & 01000000))
9884 touch_atime(file->f_path.mnt, file->f_path.dentry);
9887 int sync_inode(struct inode *inode, struct writeback_control *wbc);
9888 # 1323 "include/linux/fs.h"
9889 struct export_operations {
9890 struct dentry *(*decode_fh)(struct super_block *sb, __u32 *fh, int fh_len, int fh_type,
9891 int (*acceptable)(void *context, struct dentry *de),
9893 int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
9897 int (*get_name)(struct dentry *parent, char *name,
9898 struct dentry *child);
9899 struct dentry * (*get_parent)(struct dentry *child);
9900 struct dentry * (*get_dentry)(struct super_block *sb, void *inump);
9903 struct dentry * (*find_exported_dentry)(
9904 struct super_block *sb, void *obj, void *parent,
9905 int (*acceptable)(void *context, struct dentry *de),
9911 extern struct dentry *
9912 find_exported_dentry(struct super_block *sb, void *obj, void *parent,
9913 int (*acceptable)(void *context, struct dentry *de),
9916 struct file_system_type {
9919 int (*get_sb) (struct file_system_type *, int,
9920 const char *, void *, struct vfsmount *);
9921 void (*kill_sb) (struct super_block *);
9922 struct module *owner;
9923 struct file_system_type * next;
9924 struct list_head fs_supers;
9925 struct lock_class_key s_lock_key;
9926 struct lock_class_key s_umount_key;
9929 extern int get_sb_bdev(struct file_system_type *fs_type,
9930 int flags, const char *dev_name, void *data,
9931 int (*fill_super)(struct super_block *, void *, int),
9932 struct vfsmount *mnt);
9933 extern int get_sb_single(struct file_system_type *fs_type,
9934 int flags, void *data,
9935 int (*fill_super)(struct super_block *, void *, int),
9936 struct vfsmount *mnt);
9937 extern int get_sb_nodev(struct file_system_type *fs_type,
9938 int flags, void *data,
9939 int (*fill_super)(struct super_block *, void *, int),
9940 struct vfsmount *mnt);
9941 void generic_shutdown_super(struct super_block *sb);
9942 void kill_block_super(struct super_block *sb);
9943 void kill_anon_super(struct super_block *sb);
9944 void kill_litter_super(struct super_block *sb);
9945 void deactivate_super(struct super_block *sb);
9946 int set_anon_super(struct super_block *s, void *data);
9947 struct super_block *sget(struct file_system_type *type,
9948 int (*test)(struct super_block *,void *),
9949 int (*set)(struct super_block *,void *),
9951 extern int get_sb_pseudo(struct file_system_type *, char *,
9952 const struct super_operations *ops, unsigned long,
9953 struct vfsmount *mnt);
9954 extern int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
9955 int __put_super(struct super_block *sb);
9956 int __put_super_and_need_restart(struct super_block *sb);
9957 void unnamed_dev_init(void);
9965 extern int register_filesystem(struct file_system_type *);
9966 extern int unregister_filesystem(struct file_system_type *);
9967 extern struct vfsmount *kern_mount(struct file_system_type *);
9968 extern int may_umount_tree(struct vfsmount *);
9969 extern int may_umount(struct vfsmount *);
9970 extern void umount_tree(struct vfsmount *, int, struct list_head *);
9971 extern void release_mounts(struct list_head *);
9972 extern long do_mount(char *, char *, char *, unsigned long, void *);
9973 extern struct vfsmount *copy_tree(struct vfsmount *, struct dentry *, int);
9974 extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
9977 extern int vfs_statfs(struct dentry *, struct kstatfs *);
9980 extern struct subsystem fs_subsys;
9985 extern int locks_mandatory_locked(struct inode *);
9986 extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
9987 # 1429 "include/linux/fs.h"
9988 static inline __attribute__((always_inline)) int locks_verify_locked(struct inode *inode)
9990 if ((((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
9991 return locks_mandatory_locked(inode);
9995 extern int rw_verify_area(int, struct file *, loff_t *, size_t);
9997 static inline __attribute__((always_inline)) int locks_verify_truncate(struct inode *inode,
10001 if (inode->i_flock && (((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
10002 return locks_mandatory_area(
10004 size < inode->i_size ? size : inode->i_size,
10005 (size < inode->i_size ? inode->i_size - size
10006 : size - inode->i_size)
10011 static inline __attribute__((always_inline)) int break_lease(struct inode *inode, unsigned int mode)
10013 if (inode->i_flock)
10014 return __break_lease(inode, mode);
10020 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
10021 struct file *filp);
10022 extern long do_sys_open(int fdf, const char *filename, int flags,
10024 extern struct file *filp_open(const char *, int, int);
10025 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
10026 extern int filp_close(struct file *, fl_owner_t id);
10027 extern char * getname(const char *);
10030 extern void __attribute__ ((__section__ (".init.text"))) vfs_caches_init_early(void);
10031 extern void __attribute__ ((__section__ (".init.text"))) vfs_caches_init(unsigned long);
10033 extern struct kmem_cache *names_cachep;
10034 # 1485 "include/linux/fs.h"
10035 extern int register_blkdev(unsigned int, const char *);
10036 extern int unregister_blkdev(unsigned int, const char *);
10037 extern struct block_device *bdget(dev_t);
10038 extern void bd_set_size(struct block_device *, loff_t size);
10039 extern void bd_forget(struct inode *inode);
10040 extern void bdput(struct block_device *);
10041 extern struct block_device *open_by_devnum(dev_t, unsigned);
10042 extern const struct address_space_operations def_blk_aops;
10046 extern const struct file_operations def_blk_fops;
10047 extern const struct file_operations def_chr_fops;
10048 extern const struct file_operations bad_sock_fops;
10049 extern const struct file_operations def_fifo_fops;
10051 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
10052 extern int blkdev_ioctl(struct inode *, struct file *, unsigned, unsigned long);
10053 extern int blkdev_driver_ioctl(struct inode *inode, struct file *file,
10054 struct gendisk *disk, unsigned cmd,
10055 unsigned long arg);
10056 extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
10057 extern int blkdev_get(struct block_device *, mode_t, unsigned);
10058 extern int blkdev_put(struct block_device *);
10059 extern int bd_claim(struct block_device *, void *);
10060 extern void bd_release(struct block_device *);
10062 extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
10063 extern void bd_release_from_disk(struct block_device *, struct gendisk *);
10064 # 1522 "include/linux/fs.h"
10065 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
10066 extern int register_chrdev_region(dev_t, unsigned, const char *);
10067 extern int register_chrdev(unsigned int, const char *,
10068 const struct file_operations *);
10069 extern int unregister_chrdev(unsigned int, const char *);
10070 extern void unregister_chrdev_region(dev_t, unsigned);
10071 extern int chrdev_open(struct inode *, struct file *);
10072 extern void chrdev_show(struct seq_file *,off_t);
10079 extern const char *__bdevname(dev_t, char *buffer);
10080 extern const char *bdevname(struct block_device *bdev, char *buffer);
10081 extern struct block_device *lookup_bdev(const char *);
10082 extern struct block_device *open_bdev_excl(const char *, int, void *);
10083 extern void close_bdev_excl(struct block_device *);
10084 extern void blkdev_show(struct seq_file *,off_t);
10089 extern void init_special_inode(struct inode *, umode_t, dev_t);
10092 extern void make_bad_inode(struct inode *);
10093 extern int is_bad_inode(struct inode *);
10095 extern const struct file_operations read_fifo_fops;
10096 extern const struct file_operations write_fifo_fops;
10097 extern const struct file_operations rdwr_fifo_fops;
10099 extern int fs_may_remount_ro(struct super_block *);
10100 # 1569 "include/linux/fs.h"
10101 extern int check_disk_change(struct block_device *);
10102 extern int __invalidate_device(struct block_device *);
10103 extern int invalidate_partition(struct gendisk *, int);
10105 extern int invalidate_inodes(struct super_block *);
10106 unsigned long invalidate_mapping_pages(struct address_space *mapping,
10107 unsigned long start, unsigned long end);
10109 static inline __attribute__((always_inline)) unsigned long __attribute__((deprecated))
10110 invalidate_inode_pages(struct address_space *mapping)
10112 return invalidate_mapping_pages(mapping, 0, ~0UL);
10115 static inline __attribute__((always_inline)) void invalidate_remote_inode(struct inode *inode)
10117 if ((((inode->i_mode) & 00170000) == 0100000) || (((inode->i_mode) & 00170000) == 0040000) ||
10118 (((inode->i_mode) & 00170000) == 0120000))
10119 invalidate_mapping_pages(inode->i_mapping, 0, -1);
10121 extern int invalidate_inode_pages2(struct address_space *mapping);
10122 extern int invalidate_inode_pages2_range(struct address_space *mapping,
10123 unsigned long start, unsigned long end);
10124 extern int write_inode_now(struct inode *, int);
10125 extern int filemap_fdatawrite(struct address_space *);
10126 extern int filemap_flush(struct address_space *);
10127 extern int filemap_fdatawait(struct address_space *);
10128 extern int filemap_write_and_wait(struct address_space *mapping);
10129 extern int filemap_write_and_wait_range(struct address_space *mapping,
10130 loff_t lstart, loff_t lend);
10131 extern int wait_on_page_writeback_range(struct address_space *mapping,
10132 unsigned long start, unsigned long end);
10133 extern int __filemap_fdatawrite_range(struct address_space *mapping,
10134 loff_t start, loff_t end, int sync_mode);
10136 extern long do_fsync(struct file *file, int datasync);
10137 extern void sync_supers(void);
10138 extern void sync_filesystems(int wait);
10139 extern void __fsync_super(struct super_block *sb);
10140 extern void emergency_sync(void);
10141 extern void emergency_remount(void);
10142 extern int do_remount_sb(struct super_block *sb, int flags,
10143 void *data, int force);
10145 extern sector_t bmap(struct inode *, sector_t);
10147 extern int notify_change(struct dentry *, struct iattr *);
10148 extern int permission(struct inode *, int, struct nameidata *);
10149 extern int generic_permission(struct inode *, int,
10150 int (*check_acl)(struct inode *, int));
10152 extern int get_write_access(struct inode *);
10153 extern int deny_write_access(struct file *);
10154 static inline __attribute__((always_inline)) void put_write_access(struct inode * inode)
10156 atomic_dec(&inode->i_writecount);
10158 static inline __attribute__((always_inline)) void allow_write_access(struct file *file)
10161 atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
10163 extern int do_pipe(int *);
10164 extern struct file *create_read_pipe(struct file *f);
10165 extern struct file *create_write_pipe(void);
10166 extern void free_write_pipe(struct file *);
10168 extern int open_namei(int dfd, const char *, int, int, struct nameidata *);
10169 extern int may_open(struct nameidata *, int, int);
10171 extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
10172 extern struct file * open_exec(const char *);
10175 extern int is_subdir(struct dentry *, struct dentry *);
10176 extern ino_t find_inode_number(struct dentry *, struct qstr *);
10178 # 1 "include/linux/err.h" 1
10179 # 22 "include/linux/err.h"
10180 static inline __attribute__((always_inline)) void *ERR_PTR(long error)
10182 return (void *) error;
10185 static inline __attribute__((always_inline)) long PTR_ERR(const void *ptr)
10190 static inline __attribute__((always_inline)) long IS_ERR(const void *ptr)
10192 return __builtin_expect(!!(((unsigned long)ptr) >= (unsigned long)-4095), 0);
10194 # 1647 "include/linux/fs.h" 2
10197 extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
10199 extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
10201 extern void inode_init_once(struct inode *);
10202 extern void iput(struct inode *);
10203 extern struct inode * igrab(struct inode *);
10204 extern ino_t iunique(struct super_block *, ino_t);
10205 extern int inode_needs_sync(struct inode *inode);
10206 extern void generic_delete_inode(struct inode *inode);
10207 extern void generic_drop_inode(struct inode *inode);
10209 extern struct inode *ilookup5_nowait(struct super_block *sb,
10210 unsigned long hashval, int (*test)(struct inode *, void *),
10212 extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
10213 int (*test)(struct inode *, void *), void *data);
10214 extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
10216 extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
10217 extern struct inode * iget_locked(struct super_block *, unsigned long);
10218 extern void unlock_new_inode(struct inode *);
10220 static inline __attribute__((always_inline)) struct inode *iget(struct super_block *sb, unsigned long ino)
10222 struct inode *inode = iget_locked(sb, ino);
10224 if (inode && (inode->i_state & 64)) {
10225 sb->s_op->read_inode(inode);
10226 unlock_new_inode(inode);
10232 extern void __iget(struct inode * inode);
10233 extern void clear_inode(struct inode *);
10234 extern void destroy_inode(struct inode *);
10235 extern struct inode *new_inode(struct super_block *);
10236 extern int __remove_suid(struct dentry *, int);
10237 extern int should_remove_suid(struct dentry *);
10238 extern int remove_suid(struct dentry *);
10240 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
10241 extern void remove_inode_hash(struct inode *);
10242 static inline __attribute__((always_inline)) void insert_inode_hash(struct inode *inode) {
10243 __insert_inode_hash(inode, inode->i_ino);
10246 extern struct file * get_empty_filp(void);
10247 extern void file_move(struct file *f, struct list_head *list);
10248 extern void file_kill(struct file *f);
10251 extern void submit_bio(int, struct bio *);
10252 extern int bdev_read_only(struct block_device *);
10254 extern int set_blocksize(struct block_device *, int);
10255 extern int sb_set_blocksize(struct super_block *, int);
10256 extern int sb_min_blocksize(struct super_block *, int);
10258 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
10259 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
10260 extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
10261 extern int file_send_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
10262 int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
10263 extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
10264 extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
10265 extern ssize_t generic_file_aio_write_nolock(struct kiocb *, const struct iovec *,
10266 unsigned long, loff_t);
10267 extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
10268 unsigned long *, loff_t, loff_t *, size_t, size_t);
10269 extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
10270 unsigned long, loff_t, loff_t *, size_t, ssize_t);
10271 extern ssize_t do_sync_read(struct file *filp, char *buf, size_t len, loff_t *ppos);
10272 extern ssize_t do_sync_write(struct file *filp, const char *buf, size_t len, loff_t *ppos);
10273 extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
10274 extern void do_generic_mapping_read(struct address_space *mapping,
10275 struct file_ra_state *, struct file *,
10276 loff_t *, read_descriptor_t *, read_actor_t);
10279 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
10280 struct pipe_inode_info *, size_t, unsigned int);
10281 extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
10282 struct file *, loff_t *, size_t, unsigned int);
10283 extern ssize_t generic_file_splice_write_nolock(struct pipe_inode_info *,
10284 struct file *, loff_t *, size_t, unsigned int);
10285 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
10286 struct file *out, loff_t *, size_t len, unsigned int flags);
10287 extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
10288 size_t len, unsigned int flags);
10291 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
10292 extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
10293 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
10294 extern loff_t remote_llseek(struct file *file, loff_t offset, int origin);
10295 extern int generic_file_open(struct inode * inode, struct file * filp);
10296 extern int nonseekable_open(struct inode * inode, struct file * filp);
10297 # 1761 "include/linux/fs.h"
10298 static inline __attribute__((always_inline)) int xip_truncate_page(struct address_space *mapping, loff_t from)
10304 static inline __attribute__((always_inline)) void do_generic_file_read(struct file * filp, loff_t *ppos,
10305 read_descriptor_t * desc,
10306 read_actor_t actor)
10308 do_generic_mapping_read(filp->f_mapping,
10317 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
10318 struct block_device *bdev, const struct iovec *iov, loff_t offset,
10319 unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
10328 static inline __attribute__((always_inline)) ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
10329 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
10330 loff_t offset, unsigned long nr_segs, get_block_t get_block,
10331 dio_iodone_t end_io)
10333 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
10334 nr_segs, get_block, end_io, DIO_LOCKING);
10337 static inline __attribute__((always_inline)) ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
10338 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
10339 loff_t offset, unsigned long nr_segs, get_block_t get_block,
10340 dio_iodone_t end_io)
10342 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
10343 nr_segs, get_block, end_io, DIO_NO_LOCKING);
10346 static inline __attribute__((always_inline)) ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
10347 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
10348 loff_t offset, unsigned long nr_segs, get_block_t get_block,
10349 dio_iodone_t end_io)
10351 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
10352 nr_segs, get_block, end_io, DIO_OWN_LOCKING);
10356 extern const struct file_operations generic_ro_fops;
10360 extern int vfs_readlink(struct dentry *, char *, int, const char *);
10361 extern int vfs_follow_link(struct nameidata *, const char *);
10362 extern int page_readlink(struct dentry *, char *, int);
10363 extern void *page_follow_link_light(struct dentry *, struct nameidata *);
10364 extern void page_put_link(struct dentry *, struct nameidata *, void *);
10365 extern int __page_symlink(struct inode *inode, const char *symname, int len,
10367 extern int page_symlink(struct inode *inode, const char *symname, int len);
10368 extern const struct inode_operations page_symlink_inode_operations;
10369 extern int generic_readlink(struct dentry *, char *, int);
10370 extern void generic_fillattr(struct inode *, struct kstat *);
10371 extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
10372 void inode_add_bytes(struct inode *inode, loff_t bytes);
10373 void inode_sub_bytes(struct inode *inode, loff_t bytes);
10374 loff_t inode_get_bytes(struct inode *inode);
10375 void inode_set_bytes(struct inode *inode, loff_t bytes);
10377 extern int vfs_readdir(struct file *, filldir_t, void *);
10379 extern int vfs_stat(char *, struct kstat *);
10380 extern int vfs_lstat(char *, struct kstat *);
10381 extern int vfs_stat_fd(int dfd, char *, struct kstat *);
10382 extern int vfs_lstat_fd(int dfd, char *, struct kstat *);
10383 extern int vfs_fstat(unsigned int, struct kstat *);
10385 extern int vfs_ioctl(struct file *, unsigned int, unsigned int, unsigned long);
10387 extern struct file_system_type *get_fs_type(const char *name);
10388 extern struct super_block *get_super(struct block_device *);
10389 extern struct super_block *user_get_super(dev_t);
10390 extern void drop_super(struct super_block *sb);
10392 extern int dcache_dir_open(struct inode *, struct file *);
10393 extern int dcache_dir_close(struct inode *, struct file *);
10394 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
10395 extern int dcache_readdir(struct file *, void *, filldir_t);
10396 extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
10397 extern int simple_statfs(struct dentry *, struct kstatfs *);
10398 extern int simple_link(struct dentry *, struct inode *, struct dentry *);
10399 extern int simple_unlink(struct inode *, struct dentry *);
10400 extern int simple_rmdir(struct inode *, struct dentry *);
10401 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
10402 extern int simple_sync_file(struct file *, struct dentry *, int);
10403 extern int simple_empty(struct dentry *);
10404 extern int simple_readpage(struct file *file, struct page *page);
10405 extern int simple_prepare_write(struct file *file, struct page *page,
10406 unsigned offset, unsigned to);
10407 extern int simple_commit_write(struct file *file, struct page *page,
10408 unsigned offset, unsigned to);
10410 extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
10411 extern ssize_t generic_read_dir(struct file *, char *, size_t, loff_t *);
10412 extern const struct file_operations simple_dir_operations;
10413 extern const struct inode_operations simple_dir_inode_operations;
10414 struct tree_descr { char *name; const struct file_operations *ops; int mode; };
10415 struct dentry *d_alloc_name(struct dentry *, const char *);
10416 extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
10417 extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
10418 extern void simple_release_fs(struct vfsmount **mount, int *count);
10420 extern ssize_t simple_read_from_buffer(void *, size_t, loff_t *, const void *, size_t);
10421 # 1892 "include/linux/fs.h"
10422 extern int inode_change_ok(struct inode *, struct iattr *);
10423 extern int __attribute__((warn_unused_result)) inode_setattr(struct inode *, struct iattr *);
10425 extern void file_update_time(struct file *file);
10427 static inline __attribute__((always_inline)) ino_t parent_ino(struct dentry *dentry)
10431 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
10432 res = dentry->d_parent->d_inode->i_ino;
10433 do { do { } while (0); (void)0; (void)(&dentry->d_lock); } while (0);
10438 extern int unshare_files(void);
10446 struct simple_transaction_argresp {
10453 char *simple_transaction_get(struct file *file, const char *buf,
10455 ssize_t simple_transaction_read(struct file *file, char *buf,
10456 size_t size, loff_t *pos);
10457 int simple_transaction_release(struct inode *inode, struct file *file);
10459 static inline __attribute__((always_inline)) void simple_transaction_set(struct file *file, size_t n)
10461 struct simple_transaction_argresp *ar = file->private_data;
10463 do { if (__builtin_expect(!!((n > ((1UL << 12) - sizeof(struct simple_transaction_argresp)))!=0), 0)) do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/fs.h", 1933, (__func__)); panic("BUG!"); } while (0); } while(0);
10469 __asm__ __volatile__("": : :"memory");
10472 # 1973 "include/linux/fs.h"
10473 static inline __attribute__((always_inline)) void __attribute__((format(printf, 1, 2)))
10474 __simple_attr_check_format(const char *fmt, ...)
10479 int simple_attr_open(struct inode *inode, struct file *file,
10480 u64 (*get)(void *), void (*set)(void *, u64),
10482 int simple_attr_close(struct inode *inode, struct file *file);
10483 ssize_t simple_attr_read(struct file *file, char *buf,
10484 size_t len, loff_t *ppos);
10485 ssize_t simple_attr_write(struct file *file, const char *buf,
10486 size_t len, loff_t *ppos);
10490 static inline __attribute__((always_inline)) char *alloc_secdata(void)
10492 return (char *)get_zeroed_page(((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
10495 static inline __attribute__((always_inline)) void free_secdata(void *secdata)
10497 free_pages(((unsigned long)secdata),0);
10499 # 16 "include/linux/mm.h" 2
10501 # 1 "include/linux/debug_locks.h" 1
10505 struct task_struct;
10507 extern int debug_locks;
10508 extern int debug_locks_silent;
10513 extern int debug_locks_off(void);
10514 # 46 "include/linux/debug_locks.h"
10515 struct task_struct;
10523 static inline __attribute__((always_inline)) void debug_show_all_locks(void)
10527 static inline __attribute__((always_inline)) void debug_show_held_locks(struct task_struct *task)
10531 static inline __attribute__((always_inline)) void
10532 debug_check_no_locks_freed(const void *from, unsigned long len)
10536 static inline __attribute__((always_inline)) void
10537 debug_check_no_locks_held(struct task_struct *task)
10540 # 18 "include/linux/mm.h" 2
10541 # 1 "include/linux/backing-dev.h" 1
10542 # 13 "include/linux/backing-dev.h"
10550 BDI_write_congested,
10551 BDI_read_congested,
10555 typedef int (congested_fn)(void *, int);
10557 struct backing_dev_info {
10558 unsigned long ra_pages;
10559 unsigned long state;
10560 unsigned int capabilities;
10561 congested_fn *congested_fn;
10562 void *congested_data;
10563 void (*unplug_io_fn)(struct backing_dev_info *, struct page *);
10564 void *unplug_io_data;
10566 # 63 "include/linux/backing-dev.h"
10567 extern struct backing_dev_info default_backing_dev_info;
10568 void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);
10570 int writeback_acquire(struct backing_dev_info *bdi);
10571 int writeback_in_progress(struct backing_dev_info *bdi);
10572 void writeback_release(struct backing_dev_info *bdi);
10574 static inline __attribute__((always_inline)) int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
10576 if (bdi->congested_fn)
10577 return bdi->congested_fn(bdi->congested_data, bdi_bits);
10578 return (bdi->state & bdi_bits);
10581 static inline __attribute__((always_inline)) int bdi_read_congested(struct backing_dev_info *bdi)
10583 return bdi_congested(bdi, 1 << BDI_read_congested);
10586 static inline __attribute__((always_inline)) int bdi_write_congested(struct backing_dev_info *bdi)
10588 return bdi_congested(bdi, 1 << BDI_write_congested);
10591 static inline __attribute__((always_inline)) int bdi_rw_congested(struct backing_dev_info *bdi)
10593 return bdi_congested(bdi, (1 << BDI_read_congested)|
10594 (1 << BDI_write_congested));
10597 void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
10598 void set_bdi_congested(struct backing_dev_info *bdi, int rw);
10599 long congestion_wait(int rw, long timeout);
10600 long congestion_wait_interruptible(int rw, long timeout);
10601 void congestion_end(int rw);
10602 # 19 "include/linux/mm.h" 2
10603 # 1 "include/linux/mm_types.h" 1
10604 # 9 "include/linux/mm_types.h"
10605 struct address_space;
10606 # 18 "include/linux/mm_types.h"
10608 unsigned long flags;
10611 atomic_t _mapcount;
10617 unsigned long private;
10624 struct address_space *mapping;
10636 unsigned long index;
10637 struct list_head lru;
10638 # 69 "include/linux/mm_types.h"
10640 # 20 "include/linux/mm.h" 2
10646 extern unsigned long max_mapnr;
10649 extern unsigned long num_physpages;
10650 extern void * high_memory;
10651 extern unsigned long vmalloc_earlyreserve;
10652 extern int page_cluster;
10655 extern int sysctl_legacy_va_layout;
10661 # 1 "include/asm/pgtable.h" 1
10665 # 1 "include/asm-generic/4level-fixup.h" 1
10666 # 5 "include/asm/pgtable.h" 2
10669 # 1 "include/asm/cplb.h" 1
10670 # 8 "include/asm/pgtable.h" 2
10672 typedef pte_t *pte_addr_t;
10673 # 33 "include/asm/pgtable.h"
10674 extern void paging_init(void);
10682 static inline __attribute__((always_inline)) int pte_file(pte_t pte)
10686 # 61 "include/asm/pgtable.h"
10687 static inline __attribute__((always_inline)) pte_t pte_rdprotect(pte_t _pte) { _pte.pte &= ~(0x00000004); return _pte; };
10688 static inline __attribute__((always_inline)) pte_t pte_mkread(pte_t _pte) { _pte.pte |= (0x00000004); return _pte; };
10689 static inline __attribute__((always_inline)) pte_t pte_wrprotect(pte_t _pte) { _pte.pte &= ~(0x00000008); return _pte; };
10690 static inline __attribute__((always_inline)) pte_t pte_mkwrite(pte_t _pte) { _pte.pte |= (0x00000008); return _pte; };
10691 static inline __attribute__((always_inline)) pte_t pte_exprotect(pte_t _pte) { _pte.pte &= ~(0x00000004 | 0x00000008); return _pte; };
10692 static inline __attribute__((always_inline)) pte_t pte_mkexec(pte_t _pte) { _pte.pte |= (0x00000004 | 0x00000008); return _pte; };
10693 static inline __attribute__((always_inline)) pte_t pte_mkclean(pte_t _pte) { _pte.pte &= ~(0x00000080); return _pte; };
10694 static inline __attribute__((always_inline)) pte_t pte_mkdirty(pte_t _pte) { _pte.pte |= (0x00000080); return _pte; };
10695 static inline __attribute__((always_inline)) pte_t pte_mkold(pte_t _pte) { _pte.pte &= ~0x00000010 | 0x00000004 | 0x00000008; return _pte; };
10696 static inline __attribute__((always_inline)) pte_t pte_mkyoung(pte_t _pte) { _pte.pte |= 0x00000010 | 0x00000004 | 0x00000008; return _pte; };
10704 extern unsigned int kobjsize(const void *objp);
10705 # 94 "include/asm/pgtable.h"
10706 # 1 "include/asm-generic/pgtable.h" 1
10707 # 130 "include/asm-generic/pgtable.h"
10709 static inline __attribute__((always_inline)) void ptep_set_wrprotect(struct mm_struct *mm, unsigned long address, pte_t *ptep)
10711 pte_t old_pte = *ptep;
10712 (*(ptep) = pte_wrprotect(old_pte));
10714 # 230 "include/asm-generic/pgtable.h"
10715 void pgd_clear_bad(pgd_t *);
10716 void pud_clear_bad(pgd_t *);
10717 void pmd_clear_bad(pmd_t *);
10719 static inline __attribute__((always_inline)) int pgd_none_or_clear_bad(pgd_t *pgd)
10723 if (__builtin_expect(!!((0)), 0)) {
10724 pgd_clear_bad(pgd);
10730 static inline __attribute__((always_inline)) int pud_none_or_clear_bad(pgd_t *pud)
10734 if (__builtin_expect(!!(0), 0)) {
10735 pud_clear_bad(pud);
10741 static inline __attribute__((always_inline)) int pmd_none_or_clear_bad(pmd_t *pmd)
10743 if ((!((&*pmd)->pmd[0])))
10745 if (__builtin_expect(!!((((&*pmd)->pmd[0]) & ~(~((1UL << 12)-1)))), 0)) {
10746 pmd_clear_bad(pmd);
10751 # 95 "include/asm/pgtable.h" 2
10752 # 41 "include/linux/mm.h" 2
10753 # 60 "include/linux/mm.h"
10754 struct vm_area_struct {
10755 struct mm_struct * vm_mm;
10756 unsigned long vm_start;
10757 unsigned long vm_end;
10761 struct vm_area_struct *vm_next;
10763 pgprot_t vm_page_prot;
10764 unsigned long vm_flags;
10766 struct rb_node vm_rb;
10776 struct list_head list;
10778 struct vm_area_struct *head;
10781 struct raw_prio_tree_node prio_tree_node;
10790 struct list_head anon_vma_node;
10791 struct anon_vma *anon_vma;
10794 struct vm_operations_struct * vm_ops;
10797 unsigned long vm_pgoff;
10799 struct file * vm_file;
10800 void * vm_private_data;
10801 unsigned long vm_truncate_count;
10811 extern struct kmem_cache *vm_area_cachep;
10818 struct vm_list_struct {
10819 struct vm_list_struct *next;
10820 struct vm_area_struct *vma;
10824 extern struct rb_root nommu_vma_tree;
10825 extern struct rw_semaphore nommu_vma_sem;
10827 extern unsigned int kobjsize(const void *objp);
10828 # 194 "include/linux/mm.h"
10829 extern pgprot_t protection_map[16];
10837 struct vm_operations_struct {
10838 void (*open)(struct vm_area_struct * area);
10839 void (*close)(struct vm_area_struct * area);
10840 struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int *type);
10841 unsigned long (*nopfn)(struct vm_area_struct * area, unsigned long address);
10842 int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);
10846 int (*page_mkwrite)(struct vm_area_struct *vma, struct page *page);
10858 # 231 "include/linux/mm.h"
10859 # 1 "include/linux/page-flags.h" 1
10860 # 256 "include/linux/page-flags.h"
10863 extern void cancel_dirty_page(struct page *page, unsigned int account_size);
10865 int test_clear_page_writeback(struct page *page);
10866 int test_set_page_writeback(struct page *page);
10868 static inline __attribute__((always_inline)) void set_page_writeback(struct page *page)
10870 test_set_page_writeback(page);
10872 # 232 "include/linux/mm.h" 2
10873 # 255 "include/linux/mm.h"
10874 static inline __attribute__((always_inline)) int put_page_testzero(struct page *page)
10877 return (atomic_sub_return(1, (&page->_count)) == 0);
10884 static inline __attribute__((always_inline)) int get_page_unless_zero(struct page *page)
10887 return ({ int c, old; c = (((&page->_count))->counter); while (c != (0) && (old = ((int)((__typeof__(*(&((((&page->_count)))->counter))))__cmpxchg((&((((&page->_count)))->counter)),(unsigned long)((c)), (unsigned long)((c + (1))),sizeof(*(&((((&page->_count)))->counter))))))) != c) c = old; c != (0); });
10890 static inline __attribute__((always_inline)) int page_count(struct page *page)
10892 if (__builtin_expect(!!((__builtin_constant_p(14) ? __constant_test_bit((14),(&(page)->flags)) : __test_bit((14),(&(page)->flags)))), 0))
10893 page = (struct page *)((page)->private);
10894 return ((&page->_count)->counter);
10897 static inline __attribute__((always_inline)) void get_page(struct page *page)
10899 if (__builtin_expect(!!((__builtin_constant_p(14) ? __constant_test_bit((14),(&(page)->flags)) : __test_bit((14),(&(page)->flags)))), 0))
10900 page = (struct page *)((page)->private);
10902 atomic_inc(&page->_count);
10909 static inline __attribute__((always_inline)) void init_page_count(struct page *page)
10911 (((&page->_count)->counter) = 1);
10914 void put_page(struct page *page);
10915 void put_pages_list(struct list_head *pages);
10917 void split_page(struct page *page, unsigned int order);
10918 void split_compound_page(struct page *page, unsigned int order);
10925 typedef void compound_page_dtor(struct page *);
10927 static inline __attribute__((always_inline)) void set_compound_page_dtor(struct page *page,
10928 compound_page_dtor *dtor)
10930 page[1].lru.next = (void *)dtor;
10933 static inline __attribute__((always_inline)) compound_page_dtor *get_compound_page_dtor(struct page *page)
10935 return (compound_page_dtor *)page[1].lru.next;
10937 # 461 "include/linux/mm.h"
10938 static inline __attribute__((always_inline)) enum zone_type page_zonenum(struct page *page)
10940 return (page->flags >> (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0))) & ((1UL << 1) - 1);
10942 # 474 "include/linux/mm.h"
10943 static inline __attribute__((always_inline)) int page_zone_id(struct page *page)
10945 return (page->flags >> ((((((sizeof(unsigned long)*8) - 0) - 0) < ((((sizeof(unsigned long)*8) - 0) - 0) - 1))? (((sizeof(unsigned long)*8) - 0) - 0) : ((((sizeof(unsigned long)*8) - 0) - 0) - 1)) * ((0 + 1) != 0))) & ((1UL << (0 + 1)) - 1);
10948 static inline __attribute__((always_inline)) int zone_to_nid(struct zone *zone)
10960 static inline __attribute__((always_inline)) int page_to_nid(struct page *page)
10962 return (page->flags >> ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0))) & ((1UL << 0) - 1);
10966 static inline __attribute__((always_inline)) struct zone *page_zone(struct page *page)
10968 return &(&contig_page_data)->node_zones[page_zonenum(page)];
10971 static inline __attribute__((always_inline)) unsigned long page_to_section(struct page *page)
10973 return (page->flags >> (((sizeof(unsigned long)*8) - 0) * (0 != 0))) & ((1UL << 0) - 1);
10976 static inline __attribute__((always_inline)) void set_page_zone(struct page *page, enum zone_type zone)
10978 page->flags &= ~(((1UL << 1) - 1) << (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0)));
10979 page->flags |= (zone & ((1UL << 1) - 1)) << (((((sizeof(unsigned long)*8) - 0) - 0) - 1) * (1 != 0));
10982 static inline __attribute__((always_inline)) void set_page_node(struct page *page, unsigned long node)
10984 page->flags &= ~(((1UL << 0) - 1) << ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0)));
10985 page->flags |= (node & ((1UL << 0) - 1)) << ((((sizeof(unsigned long)*8) - 0) - 0) * (0 != 0));
10988 static inline __attribute__((always_inline)) void set_page_section(struct page *page, unsigned long section)
10990 page->flags &= ~(((1UL << 0) - 1) << (((sizeof(unsigned long)*8) - 0) * (0 != 0)));
10991 page->flags |= (section & ((1UL << 0) - 1)) << (((sizeof(unsigned long)*8) - 0) * (0 != 0));
10994 static inline __attribute__((always_inline)) void set_page_links(struct page *page, enum zone_type zone,
10995 unsigned long node, unsigned long pfn)
10997 set_page_zone(page, zone);
10998 set_page_node(page, node);
10999 set_page_section(page, ((pfn) >> 0));
11005 # 1 "include/linux/vmstat.h" 1
11011 # 1 "include/linux/mm.h" 1
11012 # 7 "include/linux/vmstat.h" 2
11013 # 30 "include/linux/vmstat.h"
11014 enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
11015 PGALLOC_DMA, PGALLOC_NORMAL ,
11016 PGFREE, PGACTIVATE, PGDEACTIVATE,
11017 PGFAULT, PGMAJFAULT,
11018 PGREFILL_DMA, PGREFILL_NORMAL ,
11019 PGSTEAL_DMA, PGSTEAL_NORMAL ,
11020 PGSCAN_KSWAPD_DMA, PGSCAN_KSWAPD_NORMAL ,
11021 PGSCAN_DIRECT_DMA, PGSCAN_DIRECT_NORMAL ,
11022 PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
11023 PAGEOUTRUN, ALLOCSTALL, PGROTATED,
11026 # 54 "include/linux/vmstat.h"
11027 struct vm_event_state {
11028 unsigned long event[NR_VM_EVENT_ITEMS];
11031 extern __typeof__(struct vm_event_state) per_cpu__vm_event_states;
11033 static inline __attribute__((always_inline)) void __count_vm_event(enum vm_event_item item)
11035 per_cpu__vm_event_states.event[item]++;
11038 static inline __attribute__((always_inline)) void count_vm_event(enum vm_event_item item)
11040 (*({ extern int simple_identifier_vm_event_states(void); do { } while (0); &per_cpu__vm_event_states; })).event[item]++;
11044 static inline __attribute__((always_inline)) void __count_vm_events(enum vm_event_item item, long delta)
11046 per_cpu__vm_event_states.event[item] += delta;
11049 static inline __attribute__((always_inline)) void count_vm_events(enum vm_event_item item, long delta)
11051 (*({ extern int simple_identifier_vm_event_states(void); do { } while (0); &per_cpu__vm_event_states; })).event[item] += delta;
11055 extern void all_vm_events(unsigned long *);
11057 extern void vm_events_fold_cpu(int cpu);
11058 # 122 "include/linux/vmstat.h"
11059 extern atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
11061 static inline __attribute__((always_inline)) void zone_page_state_add(long x, struct zone *zone,
11062 enum zone_stat_item item)
11064 atomic_long_add(x, &zone->vm_stat[item]);
11065 atomic_long_add(x, &vm_stat[item]);
11068 static inline __attribute__((always_inline)) unsigned long global_page_state(enum zone_stat_item item)
11070 long x = atomic_long_read(&vm_stat[item]);
11078 static inline __attribute__((always_inline)) unsigned long zone_page_state(struct zone *zone,
11079 enum zone_stat_item item)
11081 long x = atomic_long_read(&zone->vm_stat[item]);
11088 # 193 "include/linux/vmstat.h"
11089 static inline __attribute__((always_inline)) void zap_zone_vm_stats(struct zone *zone)
11091 memset(zone->vm_stat, 0, sizeof(zone->vm_stat));
11094 extern void inc_zone_state(struct zone *, enum zone_stat_item);
11095 # 223 "include/linux/vmstat.h"
11096 static inline __attribute__((always_inline)) void __mod_zone_page_state(struct zone *zone,
11097 enum zone_stat_item item, int delta)
11099 zone_page_state_add(delta, zone, item);
11102 static inline __attribute__((always_inline)) void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
11104 atomic_long_inc(&zone->vm_stat[item]);
11105 atomic_long_inc(&vm_stat[item]);
11108 static inline __attribute__((always_inline)) void __inc_zone_page_state(struct page *page,
11109 enum zone_stat_item item)
11111 __inc_zone_state(page_zone(page), item);
11114 static inline __attribute__((always_inline)) void __dec_zone_state(struct zone *zone, enum zone_stat_item item)
11116 atomic_long_dec(&zone->vm_stat[item]);
11117 atomic_long_dec(&vm_stat[item]);
11120 static inline __attribute__((always_inline)) void __dec_zone_page_state(struct page *page,
11121 enum zone_stat_item item)
11123 atomic_long_dec(&page_zone(page)->vm_stat[item]);
11124 atomic_long_dec(&vm_stat[item]);
11126 # 262 "include/linux/vmstat.h"
11127 static inline __attribute__((always_inline)) void refresh_cpu_vm_stats(int cpu) { }
11128 static inline __attribute__((always_inline)) void refresh_vm_stats(void) { }
11129 # 537 "include/linux/mm.h" 2
11131 static inline __attribute__((always_inline)) __attribute__((always_inline)) void *lowmem_page_address(struct page *page)
11133 return ((void *) ((unsigned long)((((unsigned long) ((void *)(((((page) - mem_map) << 12) + (0x00000000))))) >> 12) << 12)));
11135 # 579 "include/linux/mm.h"
11136 extern struct address_space swapper_space;
11137 static inline __attribute__((always_inline)) struct address_space *page_mapping(struct page *page)
11139 struct address_space *mapping = page->mapping;
11141 if (__builtin_expect(!!(0), 0))
11142 mapping = &swapper_space;
11143 else if (__builtin_expect(!!((unsigned long)mapping & 1), 0))
11144 mapping = ((void *)0);
11148 static inline __attribute__((always_inline)) int PageAnon(struct page *page)
11150 return ((unsigned long)page->mapping & 1) != 0;
11157 static inline __attribute__((always_inline)) unsigned long page_index(struct page *page)
11159 if (__builtin_expect(!!(0), 0))
11160 return ((page)->private);
11161 return page->index;
11169 static inline __attribute__((always_inline)) void reset_page_mapcount(struct page *page)
11171 (((&(page)->_mapcount)->counter) = -1);
11174 static inline __attribute__((always_inline)) int page_mapcount(struct page *page)
11176 return ((&(page)->_mapcount)->counter) + 1;
11182 static inline __attribute__((always_inline)) int page_mapped(struct page *page)
11184 return ((&(page)->_mapcount)->counter) >= 0;
11186 # 662 "include/linux/mm.h"
11187 extern void show_free_areas(void);
11195 static inline __attribute__((always_inline)) int shmem_lock(struct file *file, int lock,
11196 struct user_struct *user)
11201 static inline __attribute__((always_inline)) int shmem_set_policy(struct vm_area_struct *vma,
11202 struct mempolicy *new)
11207 static inline __attribute__((always_inline)) struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
11208 unsigned long addr)
11210 return ((void *)0);
11213 struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
11215 int shmem_zero_setup(struct vm_area_struct *);
11218 extern unsigned long shmem_get_unmapped_area(struct file *file,
11219 unsigned long addr,
11221 unsigned long pgoff,
11222 unsigned long flags);
11225 static inline __attribute__((always_inline)) int can_do_mlock(void)
11229 if ((get_current())->signal->rlim[8].rlim_cur != 0)
11233 extern int user_shm_lock(size_t, struct user_struct *);
11234 extern void user_shm_unlock(size_t, struct user_struct *);
11239 struct zap_details {
11240 struct vm_area_struct *nonlinear_vma;
11241 struct address_space *check_mapping;
11242 unsigned long first_index;
11243 unsigned long last_index;
11244 spinlock_t *i_mmap_lock;
11245 unsigned long truncate_count;
11248 struct page *vm_normal_page(struct vm_area_struct *, unsigned long, pte_t);
11249 unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
11250 unsigned long size, struct zap_details *);
11251 unsigned long unmap_vmas(struct mmu_gather **tlb,
11252 struct vm_area_struct *start_vma, unsigned long start_addr,
11253 unsigned long end_addr, unsigned long *nr_accounted,
11254 struct zap_details *);
11255 void free_pgd_range(struct mmu_gather **tlb, unsigned long addr,
11256 unsigned long end, unsigned long floor, unsigned long ceiling);
11257 void free_pgtables(struct mmu_gather **tlb, struct vm_area_struct *start_vma,
11258 unsigned long floor, unsigned long ceiling);
11259 int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
11260 struct vm_area_struct *vma);
11261 int zeromap_page_range(struct vm_area_struct *vma, unsigned long from,
11262 unsigned long size, pgprot_t prot);
11263 void unmap_mapping_range(struct address_space *mapping,
11264 loff_t const holebegin, loff_t const holelen, int even_cows);
11266 static inline __attribute__((always_inline)) void unmap_shared_mapping_range(struct address_space *mapping,
11267 loff_t const holebegin, loff_t const holelen)
11269 unmap_mapping_range(mapping, holebegin, holelen, 0);
11272 extern int vmtruncate(struct inode * inode, loff_t offset);
11273 extern int vmtruncate_range(struct inode * inode, loff_t offset, loff_t end);
11274 extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
11275 extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
11276 # 764 "include/linux/mm.h"
11277 static inline __attribute__((always_inline)) int handle_mm_fault(struct mm_struct *mm,
11278 struct vm_area_struct *vma, unsigned long address,
11282 do { printk("BUG: failure at %s:%d/%s()!\n", "include/linux/mm.h", 769, (__func__)); panic("BUG!"); } while (0);
11287 extern int make_pages_present(unsigned long addr, unsigned long end);
11288 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
11289 void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
11291 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
11292 int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
11293 void print_bad_pte(struct vm_area_struct *, pte_t, unsigned long);
11295 extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
11296 extern void do_invalidatepage(struct page *page, unsigned long offset);
11298 int __set_page_dirty_nobuffers(struct page *page);
11299 int __set_page_dirty_no_writeback(struct page *page);
11300 int redirty_page_for_writepage(struct writeback_control *wbc,
11301 struct page *page);
11302 int set_page_dirty(struct page *page);
11303 int set_page_dirty_lock(struct page *page);
11304 int clear_page_dirty_for_io(struct page *page);
11306 extern unsigned long do_mremap(unsigned long addr,
11307 unsigned long old_len, unsigned long new_len,
11308 unsigned long flags, unsigned long new_addr);
11309 # 808 "include/linux/mm.h"
11310 typedef int (*shrinker_t)(int nr_to_scan, gfp_t gfp_mask);
11319 extern struct shrinker *set_shrinker(int, shrinker_t);
11320 extern void remove_shrinker(struct shrinker *shrinker);
11328 static inline __attribute__((always_inline)) int vma_wants_writenotify(struct vm_area_struct *vma)
11330 unsigned int vm_flags = vma->vm_flags;
11333 if ((vm_flags & (0x00000002|0x00000008)) != ((0x00000002|0x00000008)))
11337 if (vma->vm_ops && vma->vm_ops->page_mkwrite)
11341 if (((vma->vm_page_prot).pgprot) !=
11342 ((protection_map[vm_flags & (0x00000001|0x00000002|0x00000004|0x00000008)]).pgprot))
11347 if (vm_flags & (0x00000400|0x02000000))
11351 return vma->vm_file && vma->vm_file->f_mapping &&
11352 (!(((vma->vm_file->f_mapping)->backing_dev_info)->capabilities & 0x00000001));
11355 extern pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr, spinlock_t **ptl);
11357 int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
11358 int __pmd_alloc(struct mm_struct *mm, pgd_t *pud, unsigned long address);
11359 int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
11360 int __pte_alloc_kernel(pmd_t *pmd, unsigned long address);
11361 # 926 "include/linux/mm.h"
11362 extern void free_area_init(unsigned long * zones_size);
11363 extern void free_area_init_node(int nid, pg_data_t *pgdat,
11364 unsigned long * zones_size, unsigned long zone_start_pfn,
11365 unsigned long *zholes_size);
11366 # 979 "include/linux/mm.h"
11367 extern void set_dma_reserve(unsigned long new_dma_reserve);
11368 extern void memmap_init_zone(unsigned long, int, unsigned long,
11369 unsigned long, enum memmap_context);
11370 extern void setup_per_zone_pages_min(void);
11371 extern void mem_init(void);
11372 extern void show_mem(void);
11373 extern void si_meminfo(struct sysinfo * val);
11374 extern void si_meminfo_node(struct sysinfo *val, int nid);
11379 static inline __attribute__((always_inline)) void setup_per_cpu_pageset(void) {}
11383 void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
11384 void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
11385 void vma_prio_tree_remove(struct vm_area_struct *, struct prio_tree_root *);
11386 struct vm_area_struct *vma_prio_tree_next(struct vm_area_struct *vma,
11387 struct prio_tree_iter *iter);
11393 static inline __attribute__((always_inline)) void vma_nonlinear_insert(struct vm_area_struct *vma,
11394 struct list_head *list)
11396 vma->shared.vm_set.parent = ((void *)0);
11397 list_add_tail(&vma->shared.vm_set.list, list);
11401 extern int __vm_enough_memory(long pages, int cap_sys_admin);
11402 extern void vma_adjust(struct vm_area_struct *vma, unsigned long start,
11403 unsigned long end, unsigned long pgoff, struct vm_area_struct *insert);
11404 extern struct vm_area_struct *vma_merge(struct mm_struct *,
11405 struct vm_area_struct *prev, unsigned long addr, unsigned long end,
11406 unsigned long vm_flags, struct anon_vma *, struct file *, unsigned long,
11407 struct mempolicy *);
11408 extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
11409 extern int split_vma(struct mm_struct *,
11410 struct vm_area_struct *, unsigned long addr, int new_below);
11411 extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
11412 extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
11413 struct rb_node **, struct rb_node *);
11414 extern void unlink_file_vma(struct vm_area_struct *);
11415 extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
11416 unsigned long addr, unsigned long len, unsigned long pgoff);
11417 extern void exit_mmap(struct mm_struct *);
11418 extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
11419 extern int install_special_mapping(struct mm_struct *mm,
11420 unsigned long addr, unsigned long len,
11421 unsigned long flags, struct page **pages);
11423 extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
11425 extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
11426 unsigned long len, unsigned long prot,
11427 unsigned long flag, unsigned long pgoff);
11429 static inline __attribute__((always_inline)) unsigned long do_mmap(struct file *file, unsigned long addr,
11430 unsigned long len, unsigned long prot,
11431 unsigned long flag, unsigned long offset)
11433 unsigned long ret = -22;
11434 if ((offset + (((len)+(1UL << 12)-1)&(~((1UL << 12)-1)))) < offset)
11436 if (!(offset & ~(~((1UL << 12)-1))))
11437 ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> 12);
11442 extern int do_munmap(struct mm_struct *, unsigned long, size_t);
11444 extern unsigned long do_brk(unsigned long, unsigned long);
11447 extern unsigned long page_unuse(struct page *);
11448 extern void truncate_inode_pages(struct address_space *, loff_t);
11449 extern void truncate_inode_pages_range(struct address_space *,
11450 loff_t lstart, loff_t lend);
11453 extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int *);
11454 extern int filemap_populate(struct vm_area_struct *, unsigned long,
11455 unsigned long, pgprot_t, unsigned long, int);
11458 int write_one_page(struct page *page, int wait);
11466 int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
11467 unsigned long offset, unsigned long nr_to_read);
11468 int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
11469 unsigned long offset, unsigned long nr_to_read);
11470 unsigned long page_cache_readahead(struct address_space *mapping,
11471 struct file_ra_state *ra,
11473 unsigned long offset,
11474 unsigned long size);
11475 void handle_ra_miss(struct address_space *mapping,
11476 struct file_ra_state *ra, unsigned long offset);
11477 unsigned long max_sane_readahead(unsigned long nr);
11480 extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
11486 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
11487 extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
11488 struct vm_area_struct **pprev);
11492 static inline __attribute__((always_inline)) struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
11494 struct vm_area_struct * vma = find_vma(mm,start_addr);
11496 if (vma && end_addr <= vma->vm_start)
11501 static inline __attribute__((always_inline)) unsigned long vma_pages(struct vm_area_struct *vma)
11503 return (vma->vm_end - vma->vm_start) >> 12;
11506 pgprot_t vm_get_page_prot(unsigned long vm_flags);
11507 struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
11508 struct page *vmalloc_to_page(void *addr);
11509 unsigned long vmalloc_to_pfn(void *addr);
11510 int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
11511 unsigned long pfn, unsigned long size, pgprot_t);
11512 int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
11513 int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
11514 unsigned long pfn);
11516 struct page *follow_page(struct vm_area_struct *, unsigned long address,
11517 unsigned int foll_flags);
11524 void vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
11525 # 1145 "include/linux/mm.h"
11526 static inline __attribute__((always_inline)) void
11527 kernel_map_pages(struct page *page, int numpages, int enable) {}
11530 extern struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
11535 int in_gate_area_no_task(unsigned long addr);
11539 int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *,
11540 void *, size_t *, loff_t *);
11541 unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
11542 unsigned long lru_pages);
11543 void drop_pagecache(void);
11544 void drop_slab(void);
11552 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma);
11553 # 14 "include/asm/uaccess.h" 2
11554 # 24 "include/asm/uaccess.h"
11555 static inline __attribute__((always_inline)) void set_fs(mm_segment_t fs)
11557 current_thread_info()->addr_limit = fs;
11559 # 36 "include/asm/uaccess.h"
11560 static inline __attribute__((always_inline)) int is_in_rom(unsigned long addr)
11562 # 46 "include/asm/uaccess.h"
11563 if ((addr < _ramstart) || (addr >= _ramend))
11569 # 63 "include/asm/uaccess.h"
11570 extern int _access_ok(unsigned long addr, unsigned long size)__attribute__((l1_text));
11571 # 82 "include/asm/uaccess.h"
11572 struct exception_table_entry {
11573 unsigned long insn, fixup;
11577 extern unsigned long search_exception_table(unsigned long);
11578 # 129 "include/asm/uaccess.h"
11579 static inline __attribute__((always_inline)) int bad_user_access_length(void)
11581 panic("bad_user_access_length");
11584 # 212 "include/asm/uaccess.h"
11585 static inline __attribute__((always_inline)) long copy_from_user(void *to,
11586 const void * from, unsigned long n)
11588 if (_access_ok((unsigned long)(from),(n)))
11589 memcpy(to, from, n);
11595 static inline __attribute__((always_inline)) long copy_to_user(void *to,
11596 const void * from, unsigned long n)
11598 if (_access_ok((unsigned long)(to),(n)))
11599 memcpy(to, from, n);
11609 static inline __attribute__((always_inline)) long strncpy_from_user(char *dst,
11610 const char *src, long count)
11613 if (!_access_ok((unsigned long)(src),(1)))
11615 strncpy(dst, src, count);
11616 for (tmp = dst; *tmp && count > 0; tmp++, count--) ;
11617 return (tmp - dst);
11625 static inline __attribute__((always_inline)) long strnlen_user(const char *src, long n)
11627 return (strlen(src) + 1);
11636 static inline __attribute__((always_inline)) unsigned long clear_user(void *to, unsigned long n)
11643 ssize_t sys_sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
11650 if (__builtin_expect(!!(({ int _err = 0; typeof(*(offset)) *_p = (offset); if (!_access_ok((unsigned long)(_p),(sizeof(*(_p))))) { _err = -14; } else { switch (sizeof(*(_p))) { case 1: { unsigned long _tmp; __asm__ ("%0 =" "B" "[%1]""(Z)"";\n\t" : "=d" (_tmp) : "a" (((unsigned long *)(_p)))); (off) = (__typeof__(*(_p))) _tmp; }; break; case 2: { unsigned long _tmp; __asm__ ("%0 =" "W" "[%1]""(Z)"";\n\t" : "=d" (_tmp) : "a" (((unsigned long *)(_p)))); (off) = (__typeof__(*(_p))) _tmp; }; break; case 4: { unsigned long _tmp; __asm__ ("%0 =" "" "[%1]"""";\n\t" : "=d" (_tmp) : "a" (((unsigned long *)(_p)))); (off) = (__typeof__(*(_p))) _tmp; }; break; case 8: { unsigned long _xl, _xh; { unsigned long _tmp; __asm__ ("%0 =" "" "[%1]"""";\n\t" : "=d" (_tmp) : "a" (((unsigned long *)(((unsigned long *)_p)+0)))); (_xl) = (__typeof__(*(((unsigned long *)_p)+0))) _tmp; }; { unsigned long _tmp; __asm__ ("%0 =" "" "[%1]"""";\n\t" : "=d" (_tmp) : "a" (((unsigned long *)(((unsigned long *)_p)+1)))); (_xh) = (__typeof__(*(((unsigned long *)_p)+1))) _tmp; }; ((unsigned long *)&off)[0] = _xl; ((unsigned long *)&off)[1] = _xh; } break; default: off = 0; printk("<6>" "get_user_bad: %s:%d %s\n", "fs/foo.c", 10, (__func__)); _err = (bad_user_access_length(), (-14)); break; } } _err; })), 0))
11654 if (__builtin_expect(!!(({ int _err = 0; typeof(*(offset)) _x = (pos); typeof(*(offset)) *_p = (offset); if (!_access_ok((unsigned long)(_p),(sizeof(*(_p))))) { _err = -14; } else { switch (sizeof (*(_p))) { case 1: __asm__ ("B""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 2: __asm__ ("W""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 4: __asm__ ("""[%1] = %0;\n\t" : :"d" (_x),"a" (((unsigned long *)(_p))) : "memory"); break; case 8: { long _xl, _xh; _xl = ((long *)&_x)[0]; _xh = ((long *)&_x)[1]; __asm__ ("""[%1] = %0;\n\t" : :"d" (_xl),"a" (((unsigned long *)(((long *)_p)+0))) : "memory"); __asm__ ("""[%1] = %0;\n\t" : :"d" (_xh),"a" (((unsigned long *)(((long *)_p)+1))) : "memory"); } break; default: _err = (printk("<6>" "put_user_bad %s:%d %s\n", "fs/foo.c", 14, (__func__)), bad_user_access_length(), (-14)); break; } } _err; })), 0))