From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <gcc-prs-return-13983-listarch-gcc-prs=gcc.gnu.org@gcc.gnu.org>
Received: (qmail 13105 invoked by alias); 18 Jan 2002 00:26:06 -0000
Mailing-List: contact gcc-prs-help@gcc.gnu.org; run by ezmlm
Precedence: bulk
List-Archive: <http://gcc.gnu.org/ml/gcc-prs/>
List-Post: <mailto:gcc-prs@gcc.gnu.org>
List-Help: <mailto:gcc-prs-help@gcc.gnu.org>
Sender: gcc-prs-owner@gcc.gnu.org
Received: (qmail 13058 invoked by uid 71); 18 Jan 2002 00:26:03 -0000
Resent-Date: 18 Jan 2002 00:26:03 -0000
Resent-Message-ID: <20020118002603.13057.qmail@sources.redhat.com>
Resent-From: gcc-gnats@gcc.gnu.org (GNATS Filer)
Resent-To: nobody@gcc.gnu.org
Resent-Cc: gcc-prs@gcc.gnu.org, gcc-bugs@gcc.gnu.org
Resent-Reply-To: gcc-gnats@gcc.gnu.org, davidm@hpl.hp.com
Received:(qmail 11454 invoked from network); 18 Jan 2002 00:21:15 -0000
Received: from unknown (HELO palrel13.hp.com) (156.153.255.238)
  by sources.redhat.com with SMTP; 18 Jan 2002 00:21:15 -0000
Received: from wailua.hpl.hp.com (wailua.hpl.hp.com [15.4.89.122])
	by palrel13.hp.com (Postfix) with ESMTP id DCC64E004DB
	for <gcc-gnats@gcc.gnu.org>; Thu, 17 Jan 2002 16:21:14 -0800 (PST)
Received: (from davidm@localhost)
	by wailua.hpl.hp.com (8.11.2/8.11.2/client.cv) id g0I0LEV24041;
	Thu, 17 Jan 2002 16:21:14 -0800
Message-Id:<200201180021.g0I0LEV24041@wailua.hpl.hp.com>
Date: Thu, 17 Jan 2002 16:26:00 -0000
From: davidm@hpl.hp.com
To: gcc-gnats@gcc.gnu.org
X-Send-Pr-Version:3.113
Subject: c/5419: ICE with gcc3.1/ia64 on sched.c 
X-SW-Source: 2002-01/txt/msg00634.txt.bz2
List-Id: <gcc-prs.sourceware.org>


>Number:         5419
>Category:       c
>Synopsis:       ICE when compiling Linux kernel's kernel/sched.c on ia64
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-legal-code
>Submitter-Id:   net
>Arrival-Date:   Thu Jan 17 16:26:02 PST 2002
>Closed-Date:
>Last-Modified:
>Originator:     David Mosberger
>Release:        3.1 20020117 (experimental)
>Organization:
HP Labs
>Environment:
System: Linux wailua.hpl.hp.com 2.4.17 #2 SMP Thu Jan 17 13:53:26 PST 2002 ia64 unknown
Architecture: ia64

	ia64, Linux, ia64
host: ia64-hp-linux-gnu
build: ia64-hp-linux-gnu
target: ia64-hp-linux-gnu
configured with: ../gcc/configure --prefix=/opt/gcc3.1 --host=ia64-hp-linux : (reconfigured) 
>Description:
	The compiler gets an ICE when compiling the attached file with
	option -frename-registers.
>How-To-Repeat:
	$ cc1 -frename-registers sched.i
	kernel/sched.c:156: Internal compiler error in verify_local_live_at_start, at flow.c:578
>Fix:
	unknown

<-- sched.i --><-- sched.i --><-- sched.i --><-- sched.i --><-- sched.i -->
# 1 "kernel/sched.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "kernel/sched.c"
# 15 "kernel/sched.c"
# 1 "/data1/src/linux/include/linux/mm.h" 1



# 1 "/data1/src/linux/include/linux/sched.h" 1



# 1 "/data1/src/linux/include/asm/param.h" 1
# 11 "/data1/src/linux/include/asm/param.h"
# 1 "/data1/src/linux/include/linux/config.h" 1



# 1 "/data1/src/linux/include/linux/autoconf.h" 1
# 5 "/data1/src/linux/include/linux/config.h" 2
# 12 "/data1/src/linux/include/asm/param.h" 2
# 5 "/data1/src/linux/include/linux/sched.h" 2

extern unsigned long event;


# 1 "/data1/src/linux/include/linux/binfmts.h" 1



# 1 "/data1/src/linux/include/linux/ptrace.h" 1
# 24 "/data1/src/linux/include/linux/ptrace.h"
# 1 "/data1/src/linux/include/asm/ptrace.h" 1
# 53 "/data1/src/linux/include/asm/ptrace.h"
# 1 "/data1/src/linux/include/asm/fpu.h" 1
# 9 "/data1/src/linux/include/asm/fpu.h"
# 1 "/data1/src/linux/include/asm/types.h" 1
# 25 "/data1/src/linux/include/asm/types.h"
typedef unsigned int umode_t;






typedef __signed__ char __s8;
typedef unsigned char __u8;

typedef __signed__ short __s16;
typedef unsigned short __u16;

typedef __signed__ int __s32;
typedef unsigned int __u32;

typedef __signed__ long __s64;
typedef unsigned long __u64;






typedef __s8 s8;
typedef __u8 u8;

typedef __s16 s16;
typedef __u16 u16;

typedef __s32 s32;
typedef __u32 u32;

typedef __s64 s64;
typedef __u64 u64;





typedef u64 dma_addr_t;
# 10 "/data1/src/linux/include/asm/fpu.h" 2
# 57 "/data1/src/linux/include/asm/fpu.h"
struct ia64_fpreg {
        union {
                unsigned long bits[2];
        } u;
} __attribute__ ((aligned (16)));
# 54 "/data1/src/linux/include/asm/ptrace.h" 2
# 1 "/data1/src/linux/include/asm/offsets.h" 1
# 55 "/data1/src/linux/include/asm/ptrace.h" 2
# 77 "/data1/src/linux/include/asm/ptrace.h"
# 1 "/data1/src/linux/include/asm/current.h" 1
# 11 "/data1/src/linux/include/asm/current.h"
register struct task_struct *current asm ("r13");
# 78 "/data1/src/linux/include/asm/ptrace.h" 2
# 1 "/data1/src/linux/include/asm/page.h" 1
# 40 "/data1/src/linux/include/asm/page.h"
extern void clear_page (void *page);
extern void copy_page (void *to, void *from);
# 70 "/data1/src/linux/include/asm/page.h"
typedef union ia64_va {
        struct {
                unsigned long off : 61;
                unsigned long reg : 3;
        } f;
        unsigned long l;
        void *p;
} ia64_va;
# 97 "/data1/src/linux/include/asm/page.h"
static __inline__ int
get_order (unsigned long size)
{
        double d = size - 1;
        long order;

        __asm__ ("getf.exp %0=%1" : "=r"(order) : "f"(d));
        order = order - 14 - 0xffff + 1;
        if (order < 0)
                order = 0;
        return order;
}
# 117 "/data1/src/linux/include/asm/page.h"
  typedef struct { unsigned long pte; } pte_t;
  typedef struct { unsigned long pmd; } pmd_t;
  typedef struct { unsigned long pgd; } pgd_t;
  typedef struct { unsigned long pgprot; } pgprot_t;
# 79 "/data1/src/linux/include/asm/ptrace.h" 2
# 92 "/data1/src/linux/include/asm/ptrace.h"
struct pt_regs {


        unsigned long cr_ipsr;
        unsigned long cr_iip;
        unsigned long cr_ifs;

        unsigned long ar_unat;
        unsigned long ar_pfs;
        unsigned long ar_rsc;

        unsigned long ar_rnat;
        unsigned long ar_bspstore;

        unsigned long pr;
        unsigned long b6;
        unsigned long loadrs;

        unsigned long r1;
        unsigned long r2;
        unsigned long r3;
        unsigned long r12;
        unsigned long r13;
        unsigned long r14;
        unsigned long r15;

        unsigned long r8;
        unsigned long r9;
        unsigned long r10;
        unsigned long r11;



        unsigned long r16;
        unsigned long r17;
        unsigned long r18;
        unsigned long r19;
        unsigned long r20;
        unsigned long r21;
        unsigned long r22;
        unsigned long r23;
        unsigned long r24;
        unsigned long r25;
        unsigned long r26;
        unsigned long r27;
        unsigned long r28;
        unsigned long r29;
        unsigned long r30;
        unsigned long r31;

        unsigned long ar_ccv;
        unsigned long ar_fpsr;

        unsigned long b0;
        unsigned long b7;




        struct ia64_fpreg f6;
        struct ia64_fpreg f7;
        struct ia64_fpreg f8;
        struct ia64_fpreg f9;
};






struct switch_stack {
        unsigned long caller_unat;
        unsigned long ar_fpsr;

        struct ia64_fpreg f2;
        struct ia64_fpreg f3;
        struct ia64_fpreg f4;
        struct ia64_fpreg f5;

        struct ia64_fpreg f10;
        struct ia64_fpreg f11;
        struct ia64_fpreg f12;
        struct ia64_fpreg f13;
        struct ia64_fpreg f14;
        struct ia64_fpreg f15;
        struct ia64_fpreg f16;
        struct ia64_fpreg f17;
        struct ia64_fpreg f18;
        struct ia64_fpreg f19;
        struct ia64_fpreg f20;
        struct ia64_fpreg f21;
        struct ia64_fpreg f22;
        struct ia64_fpreg f23;
        struct ia64_fpreg f24;
        struct ia64_fpreg f25;
        struct ia64_fpreg f26;
        struct ia64_fpreg f27;
        struct ia64_fpreg f28;
        struct ia64_fpreg f29;
        struct ia64_fpreg f30;
        struct ia64_fpreg f31;

        unsigned long r4;
        unsigned long r5;
        unsigned long r6;
        unsigned long r7;

        unsigned long b0;
        unsigned long b1;
        unsigned long b2;
        unsigned long b3;
        unsigned long b4;
        unsigned long b5;

        unsigned long ar_pfs;
        unsigned long ar_lc;
        unsigned long ar_unat;
        unsigned long ar_rnat;
        unsigned long ar_bspstore;
        unsigned long pr;
};







  struct task_struct;

  extern void show_regs (struct pt_regs *);
  extern unsigned long ia64_get_user_rbs_end (struct task_struct *, struct pt_regs *,
                                              unsigned long *);
  extern long ia64_peek (struct task_struct *, struct switch_stack *, unsigned long,
                         unsigned long, long *);
  extern long ia64_poke (struct task_struct *, struct switch_stack *, unsigned long,
                         unsigned long, long);
  extern void ia64_flush_fph (struct task_struct *);
  extern void ia64_sync_fph (struct task_struct *);
  extern long ia64_sync_user_rbs (struct task_struct *, struct switch_stack *,
                                  unsigned long, unsigned long);


  extern unsigned long ia64_get_scratch_nat_bits (struct pt_regs *pt, unsigned long scratch_unat);

  extern unsigned long ia64_put_scratch_nat_bits (struct pt_regs *pt, unsigned long nat);

  extern void ia64_increment_ip (struct pt_regs *pt);
  extern void ia64_decrement_ip (struct pt_regs *pt);

static inline void
force_successful_syscall_return (void)
{
        (((struct pt_regs *) ((char *) (current) + ((1 << 1)*(1UL << 14)))) - 1)->r8 = 0;
}
# 25 "/data1/src/linux/include/linux/ptrace.h" 2
# 5 "/data1/src/linux/include/linux/binfmts.h" 2
# 1 "/data1/src/linux/include/linux/capability.h" 1
# 16 "/data1/src/linux/include/linux/capability.h"
# 1 "/data1/src/linux/include/linux/types.h" 1







# 1 "/data1/src/linux/include/linux/posix_types.h" 1



# 1 "/data1/src/linux/include/linux/stddef.h" 1
# 5 "/data1/src/linux/include/linux/posix_types.h" 2
# 36 "/data1/src/linux/include/linux/posix_types.h"
typedef struct {
        unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;

# 1 "/data1/src/linux/include/asm/posix_types.h" 1
# 13 "/data1/src/linux/include/asm/posix_types.h"
typedef unsigned int __kernel_dev_t;
typedef unsigned int __kernel_ino_t;
typedef unsigned int __kernel_mode_t;
typedef unsigned int __kernel_nlink_t;
typedef long __kernel_off_t;
typedef long long __kernel_loff_t;
typedef int __kernel_pid_t;
typedef int __kernel_ipc_pid_t;
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
typedef unsigned long __kernel_size_t;
typedef long __kernel_ssize_t;
typedef long __kernel_ptrdiff_t;
typedef long __kernel_time_t;
typedef long __kernel_suseconds_t;
typedef long __kernel_clock_t;
typedef int __kernel_daddr_t;
typedef char * __kernel_caddr_t;
typedef unsigned long __kernel_sigset_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;

typedef struct {
        int val[2];
} __kernel_fsid_t;

typedef __kernel_uid_t __kernel_old_uid_t;
typedef __kernel_gid_t __kernel_old_gid_t;
typedef __kernel_uid_t __kernel_uid32_t;
typedef __kernel_gid_t __kernel_gid32_t;
# 59 "/data1/src/linux/include/asm/posix_types.h"
static __inline__ void __FD_SET(unsigned long fd, __kernel_fd_set *fdsetp)
{
        unsigned long _tmp = fd / (8 * sizeof(unsigned long));
        unsigned long _rem = fd % (8 * sizeof(unsigned long));
        fdsetp->fds_bits[_tmp] |= (1UL<<_rem);
}


static __inline__ void __FD_CLR(unsigned long fd, __kernel_fd_set *fdsetp)
{
        unsigned long _tmp = fd / (8 * sizeof(unsigned long));
        unsigned long _rem = fd % (8 * sizeof(unsigned long));
        fdsetp->fds_bits[_tmp] &= ~(1UL<<_rem);
}


static __inline__ int __FD_ISSET(unsigned long fd, const __kernel_fd_set *p)
{
        unsigned long _tmp = fd / (8 * sizeof(unsigned long));
        unsigned long _rem = fd % (8 * sizeof(unsigned long));
        return (p->fds_bits[_tmp] & (1UL<<_rem)) != 0;
}






static __inline__ void __FD_ZERO(__kernel_fd_set *p)
{
        unsigned long *tmp = p->fds_bits;
        int i;

        if (__builtin_constant_p((1024/(8 * sizeof(unsigned long))))) {
                switch ((1024/(8 * sizeof(unsigned long)))) {
                      case 16:
                        tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                        tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
                        tmp[ 8] = 0; tmp[ 9] = 0; tmp[10] = 0; tmp[11] = 0;
                        tmp[12] = 0; tmp[13] = 0; tmp[14] = 0; tmp[15] = 0;
                        return;

                      case 8:
                        tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                        tmp[ 4] = 0; tmp[ 5] = 0; tmp[ 6] = 0; tmp[ 7] = 0;
                        return;

                      case 4:
                        tmp[ 0] = 0; tmp[ 1] = 0; tmp[ 2] = 0; tmp[ 3] = 0;
                        return;
                }
        }
        i = (1024/(8 * sizeof(unsigned long)));
        while (i) {
                i--;
                *tmp = 0;
                tmp++;
        }
}
# 47 "/data1/src/linux/include/linux/posix_types.h" 2
# 9 "/data1/src/linux/include/linux/types.h" 2




typedef __kernel_fd_set fd_set;
typedef __kernel_dev_t dev_t;
typedef __kernel_ino_t ino_t;
typedef __kernel_mode_t mode_t;
typedef __kernel_nlink_t nlink_t;
typedef __kernel_off_t off_t;
typedef __kernel_pid_t pid_t;
typedef __kernel_daddr_t daddr_t;
typedef __kernel_key_t key_t;
typedef __kernel_suseconds_t suseconds_t;


typedef __kernel_uid32_t uid_t;
typedef __kernel_gid32_t gid_t;
typedef __kernel_uid16_t uid16_t;
typedef __kernel_gid16_t gid16_t;
# 45 "/data1/src/linux/include/linux/types.h"
typedef __kernel_loff_t loff_t;
# 54 "/data1/src/linux/include/linux/types.h"
typedef __kernel_size_t size_t;




typedef __kernel_ssize_t ssize_t;




typedef __kernel_ptrdiff_t ptrdiff_t;




typedef __kernel_time_t time_t;




typedef __kernel_clock_t clock_t;




typedef __kernel_caddr_t caddr_t;



typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;


typedef unsigned char unchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;




typedef __u8 u_int8_t;
typedef __s8 int8_t;
typedef __u16 u_int16_t;
typedef __s16 int16_t;
typedef __u32 u_int32_t;
typedef __s32 int32_t;



typedef __u8 uint8_t;
typedef __u16 uint16_t;
typedef __u32 uint32_t;


typedef __u64 uint64_t;
typedef __u64 u_int64_t;
typedef __s64 int64_t;
# 124 "/data1/src/linux/include/linux/types.h"
typedef unsigned long sector_t;
# 134 "/data1/src/linux/include/linux/types.h"
struct ustat {
        __kernel_daddr_t f_tfree;
        __kernel_ino_t f_tinode;
        char f_fname[6];
        char f_fpack[6];
};
# 17 "/data1/src/linux/include/linux/capability.h" 2
# 1 "/data1/src/linux/include/linux/fs.h" 1
# 10 "/data1/src/linux/include/linux/fs.h"
# 1 "/data1/src/linux/include/linux/linkage.h" 1
# 11 "/data1/src/linux/include/linux/fs.h" 2
# 1 "/data1/src/linux/include/linux/limits.h" 1
# 12 "/data1/src/linux/include/linux/fs.h" 2
# 1 "/data1/src/linux/include/linux/wait.h" 1
# 13 "/data1/src/linux/include/linux/wait.h"
# 1 "/data1/src/linux/include/linux/kernel.h" 1
# 10 "/data1/src/linux/include/linux/kernel.h"
# 1 "/opt/gcc3.1/lib/gcc-lib/ia64-hp-linux/3.1/include/stdarg.h" 1 3
# 43 "/opt/gcc3.1/lib/gcc-lib/ia64-hp-linux/3.1/include/stdarg.h" 3
typedef __builtin_va_list __gnuc_va_list;
# 110 "/opt/gcc3.1/lib/gcc-lib/ia64-hp-linux/3.1/include/stdarg.h" 3
typedef __gnuc_va_list va_list;
# 11 "/data1/src/linux/include/linux/kernel.h" 2



# 1 "/data1/src/linux/include/linux/compiler.h" 1
# 15 "/data1/src/linux/include/linux/kernel.h" 2
# 40 "/data1/src/linux/include/linux/kernel.h"
extern int console_printk[];






struct completion;

extern struct notifier_block *panic_notifier_list;
 void panic(const char * fmt, ...)
        __attribute__ ((noreturn, format (printf, 1, 2)));
 __attribute__((syscall_linkage)) void do_exit(long error_code)
        __attribute__((noreturn));
 void complete_and_exit(struct completion *, long)
        __attribute__((noreturn));
extern int abs(int);
extern unsigned long simple_strtoul(const char *,char **,unsigned int);
extern long simple_strtol(const char *,char **,unsigned int);
extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
extern long long simple_strtoll(const char *,char **,unsigned int);
extern int sprintf(char * buf, const char * fmt, ...)
        __attribute__ ((format (printf, 2, 3)));
extern int vsprintf(char *buf, const char *, va_list);
extern int snprintf(char * buf, size_t size, const char * fmt, ...)
        __attribute__ ((format (printf, 3, 4)));
extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);

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

extern int get_option(char **str, int *pint);
extern char *get_options(char *str, int nints, int *ints);
extern unsigned long long memparse(char *ptr, char **retptr);
extern void dev_probe_lock(void);
extern void dev_probe_unlock(void);

extern int session_of_pgrp(int pgrp);

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

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

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

extern void bust_spinlocks(int yes);
extern int oops_in_progress;

extern int tainted;
extern const char *print_tainted(void);
# 158 "/data1/src/linux/include/linux/kernel.h"
struct sysinfo {
        long uptime;
        unsigned long loads[3];
        unsigned long totalram;
        unsigned long freeram;
        unsigned long sharedram;
        unsigned long bufferram;
        unsigned long totalswap;
        unsigned long freeswap;
        unsigned short procs;
        unsigned short pad;
        unsigned long totalhigh;
        unsigned long freehigh;
        unsigned int mem_unit;
        char _f[20-2*sizeof(long)-sizeof(int)];
};
# 14 "/data1/src/linux/include/linux/wait.h" 2
# 1 "/data1/src/linux/include/linux/list.h" 1





# 1 "/data1/src/linux/include/linux/prefetch.h" 1
# 13 "/data1/src/linux/include/linux/prefetch.h"
# 1 "/data1/src/linux/include/asm/processor.h" 1
# 19 "/data1/src/linux/include/asm/processor.h"
# 1 "/data1/src/linux/include/asm/kregs.h" 1
# 20 "/data1/src/linux/include/asm/processor.h" 2
# 1 "/data1/src/linux/include/asm/system.h" 1
# 37 "/data1/src/linux/include/asm/system.h"
struct pci_vector_struct {
        __u16 bus;
        __u32 pci_id;
        __u8 pin;
        __u8 irq;
};

extern struct ia64_boot_param {
        __u64 command_line;
        __u64 efi_systab;
        __u64 efi_memmap;
        __u64 efi_memmap_size;
        __u64 efi_memdesc_size;
        __u32 efi_memdesc_version;
        struct {
                __u16 num_cols;
                __u16 num_rows;
                __u16 orig_x;
                __u16 orig_y;
        } console_info;
        __u64 fpswa;
        __u64 initrd_start;
        __u64 initrd_size;
} *ia64_boot_param;

static inline void
ia64_insn_group_barrier (void)
{
        __asm__ __volatile__ (";;" ::: "memory");
}
# 178 "/data1/src/linux/include/asm/system.h"
  extern void __global_cli (void);
  extern void __global_sti (void);
  extern unsigned long __global_save_flags (void);
  extern void __global_restore_flags (unsigned long);
# 197 "/data1/src/linux/include/asm/system.h"
extern unsigned long __bad_size_for_ia64_fetch_and_add (void);
extern unsigned long __bad_increment_for_ia64_fetch_and_add (void);
# 242 "/data1/src/linux/include/asm/system.h"
extern void __xchg_called_with_bad_pointer (void);

static __inline__ unsigned long
__xchg (unsigned long x, volatile void *ptr, int size)
{
        unsigned long result;

        switch (size) {
              case 1:
                __asm__ __volatile ("xchg1 %0=[%1],%2" : "=r" (result)
                                    : "r" (ptr), "r" (x) : "memory");
                return result;

              case 2:
                __asm__ __volatile ("xchg2 %0=[%1],%2" : "=r" (result)
                                    : "r" (ptr), "r" (x) : "memory");
                return result;

              case 4:
                __asm__ __volatile ("xchg4 %0=[%1],%2" : "=r" (result)
                                    : "r" (ptr), "r" (x) : "memory");
                return result;

              case 8:
                __asm__ __volatile ("xchg8 %0=[%1],%2" : "=r" (result)
                                    : "r" (ptr), "r" (x) : "memory");
                return result;
        }
        __xchg_called_with_bad_pointer();
        return x;
}
# 289 "/data1/src/linux/include/asm/system.h"
extern long __cmpxchg_called_with_bad_pointer(void);
# 376 "/data1/src/linux/include/asm/system.h"
extern struct task_struct *ia64_switch_to (void *next_task);

extern void ia64_save_extra (struct task_struct *task);
extern void ia64_load_extra (struct task_struct *task);
# 21 "/data1/src/linux/include/asm/processor.h" 2
# 189 "/data1/src/linux/include/asm/processor.h"
# 1 "/data1/src/linux/include/linux/threads.h" 1
# 190 "/data1/src/linux/include/asm/processor.h" 2




# 1 "/data1/src/linux/include/asm/rse.h" 1
# 14 "/data1/src/linux/include/asm/rse.h"
static __inline__ unsigned long
ia64_rse_slot_num (unsigned long *addr)
{
        return (((unsigned long) addr) >> 3) & 0x3f;
}




static __inline__ unsigned long
ia64_rse_is_rnat_slot (unsigned long *addr)
{
        return ia64_rse_slot_num(addr) == 0x3f;
}





static __inline__ unsigned long *
ia64_rse_rnat_addr (unsigned long *slot_addr)
{
        return (unsigned long *) ((unsigned long) slot_addr | (0x3f << 3));
}






static __inline__ unsigned long
ia64_rse_num_regs (unsigned long *bspstore, unsigned long *bsp)
{
        unsigned long slots = (bsp - bspstore);

        return slots - (ia64_rse_slot_num(bspstore) + slots)/0x40;
}





static __inline__ unsigned long *
ia64_rse_skip_regs (unsigned long *addr, long num_regs)
{
        long delta = ia64_rse_slot_num(addr) + num_regs;

        if (num_regs < 0)
                delta -= 0x3e;
        return addr + num_regs + delta/0x3f;
}
# 195 "/data1/src/linux/include/asm/processor.h" 2
# 1 "/data1/src/linux/include/asm/unwind.h" 1
# 16 "/data1/src/linux/include/asm/unwind.h"
struct task_struct;
struct switch_stack;

enum unw_application_register {
        UNW_AR_BSP,
        UNW_AR_BSPSTORE,
        UNW_AR_PFS,
        UNW_AR_RNAT,
        UNW_AR_UNAT,
        UNW_AR_LC,
        UNW_AR_EC,
        UNW_AR_FPSR,
        UNW_AR_RSC,
        UNW_AR_CCV
};






struct unw_stack {
        unsigned long limit;
        unsigned long top;
};
# 49 "/data1/src/linux/include/asm/unwind.h"
struct unw_frame_info {
        struct unw_stack regstk;
        struct unw_stack memstk;
        unsigned int flags;
        short hint;
        short prev_script;


        unsigned long bsp;
        unsigned long sp;
        unsigned long psp;
        unsigned long ip;
        unsigned long pr;
        unsigned long *cfm_loc;

        struct task_struct *task;
        struct switch_stack *sw;


        unsigned long *bsp_loc;
        unsigned long *bspstore_loc;
        unsigned long *pfs_loc;
        unsigned long *rnat_loc;
        unsigned long *rp_loc;
        unsigned long *pri_unat_loc;
        unsigned long *unat_loc;
        unsigned long *pr_loc;
        unsigned long *lc_loc;
        unsigned long *fpsr_loc;
        struct unw_ireg {
                unsigned long *loc;
                struct unw_ireg_nat {
                        long type : 3;
                        signed long off : 61;
                } nat;
        } r4, r5, r6, r7;
        unsigned long *b1_loc, *b2_loc, *b3_loc, *b4_loc, *b5_loc;
        struct ia64_fpreg *f2_loc, *f3_loc, *f4_loc, *f5_loc, *fr_loc[16];
};
# 96 "/data1/src/linux/include/asm/unwind.h"
extern void unw_init (void);
extern void unw_create_gate_table (void);

extern void *unw_add_unwind_table (const char *name, unsigned long segment_base, unsigned long gp,
                                   const void *table_start, const void *table_end);

extern void unw_remove_unwind_table (void *handle);




extern void unw_init_from_blocked_task (struct unw_frame_info *info, struct task_struct *t);

extern void unw_init_frame_info (struct unw_frame_info *info, struct task_struct *t,
                                 struct switch_stack *sw);




extern void unw_init_running (void (*callback)(struct unw_frame_info *info, void *arg), void *arg);





extern int unw_unwind (struct unw_frame_info *info);






extern int unw_unwind_to_user (struct unw_frame_info *info);



static inline int
unw_get_ip (struct unw_frame_info *info, unsigned long *valp)
{
        *valp = (info)->ip;
        return 0;
}

static inline int
unw_get_sp (struct unw_frame_info *info, unsigned long *valp)
{
        *valp = (info)->sp;
        return 0;
}

static inline int
unw_get_psp (struct unw_frame_info *info, unsigned long *valp)
{
        *valp = (info)->psp;
        return 0;
}

static inline int
unw_get_bsp (struct unw_frame_info *info, unsigned long *valp)
{
        *valp = (info)->bsp;
        return 0;
}

static inline int
unw_get_cfm (struct unw_frame_info *info, unsigned long *valp)
{
        *valp = *(info)->cfm_loc;
        return 0;
}

static inline int
unw_set_cfm (struct unw_frame_info *info, unsigned long val)
{
        *(info)->cfm_loc = val;
        return 0;
}

static inline int
unw_get_rp (struct unw_frame_info *info, unsigned long *val)
{
        if (!info->rp_loc)
                return -1;
        *val = *info->rp_loc;
        return 0;
}

extern int unw_access_gr (struct unw_frame_info *, int, unsigned long *, char *, int);
extern int unw_access_br (struct unw_frame_info *, int, unsigned long *, int);
extern int unw_access_fr (struct unw_frame_info *, int, struct ia64_fpreg *, int);
extern int unw_access_ar (struct unw_frame_info *, int, unsigned long *, int);
extern int unw_access_pr (struct unw_frame_info *, unsigned long *, int);

static inline int
unw_set_gr (struct unw_frame_info *i, int n, unsigned long v, char nat)
{
        return unw_access_gr(i, n, &v, &nat, 1);
}

static inline int
unw_set_br (struct unw_frame_info *i, int n, unsigned long v)
{
        return unw_access_br(i, n, &v, 1);
}

static inline int
unw_set_fr (struct unw_frame_info *i, int n, struct ia64_fpreg v)
{
        return unw_access_fr(i, n, &v, 1);
}

static inline int
unw_set_ar (struct unw_frame_info *i, int n, unsigned long v)
{
        return unw_access_ar(i, n, &v, 1);
}

static inline int
unw_set_pr (struct unw_frame_info *i, unsigned long v)
{
        return unw_access_pr(i, &v, 1);
}
# 196 "/data1/src/linux/include/asm/processor.h" 2
# 1 "/data1/src/linux/include/asm/atomic.h" 1
# 23 "/data1/src/linux/include/asm/atomic.h"
typedef struct { volatile __s32 counter; } atomic_t;






static __inline__ int
ia64_atomic_add (int i, atomic_t *v)
{
        __s32 old, new;
       

        do {
                ;
                old = ((v)->counter);
                new = old + i;
        } while (({ __typeof__(v) _p_ = (v); __typeof__(old + i) _n_ = (old + i); __u64 _o_, _r_; switch (sizeof(atomic_t)) { case 1: _o_ = (__u8 ) (long) (old); break; case 2: _o_ = (__u16) (long) (old); break; case 4: _o_ = (__u32) (long) (old); break; case 8: _o_ = (__u64) (long) (old); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(atomic_t)) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__(old)) _r_; }) != old);
        return new;
}

static __inline__ int
ia64_atomic_sub (int i, atomic_t *v)
{
        __s32 old, new;
       

        do {
                ;
                old = ((v)->counter);
                new = old - i;
        } while (({ __typeof__(v) _p_ = (v); __typeof__(new) _n_ = (new); __u64 _o_, _r_; switch (sizeof(atomic_t)) { case 1: _o_ = (__u8 ) (long) (old); break; case 2: _o_ = (__u16) (long) (old); break; case 4: _o_ = (__u32) (long) (old); break; case 8: _o_ = (__u64) (long) (old); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(atomic_t)) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__(old)) _r_; }) != old);
        return new;
}





static __inline__ int
atomic_add_negative (int i, atomic_t *v)
{
        return ia64_atomic_add(i, v) < 0;
}
# 197 "/data1/src/linux/include/asm/processor.h" 2


struct ia64_psr {
        __u64 reserved0 : 1;
        __u64 be : 1;
        __u64 up : 1;
        __u64 ac : 1;
        __u64 mfl : 1;
        __u64 mfh : 1;
        __u64 reserved1 : 7;
        __u64 ic : 1;
        __u64 i : 1;
        __u64 pk : 1;
        __u64 reserved2 : 1;
        __u64 dt : 1;
        __u64 dfl : 1;
        __u64 dfh : 1;
        __u64 sp : 1;
        __u64 pp : 1;
        __u64 di : 1;
        __u64 si : 1;
        __u64 db : 1;
        __u64 lp : 1;
        __u64 tb : 1;
        __u64 rt : 1;
        __u64 reserved3 : 4;
        __u64 cpl : 2;
        __u64 is : 1;
        __u64 mc : 1;
        __u64 it : 1;
        __u64 id : 1;
        __u64 da : 1;
        __u64 dd : 1;
        __u64 ss : 1;
        __u64 ri : 2;
        __u64 ed : 1;
        __u64 bn : 1;
        __u64 reserved4 : 19;
};





struct cpuinfo_ia64 {

        union {
                struct {
                        __u32 irq_count;
                        __u32 bh_count;
                } f;
                __u64 irq_and_bh_counts;
        } irq_stat;
        __u32 softirq_pending;
        __u32 phys_stacked_size_p8;
        __u64 itm_delta;
        __u64 itm_next;
        __u64 *pgd_quick;
        __u64 *pmd_quick;
        __u64 *pte_quick;
        __u64 pgtable_cache_sz;

        __u64 ppn;
        __u64 features;
        __u8 number;
        __u8 revision;
        __u8 model;
        __u8 family;
        __u8 archrev;
        char vendor[16];
        __u64 itc_freq;
        __u64 proc_freq;
        __u64 cyc_per_usec;
        __u64 usec_per_cyc;
        __u64 unimpl_va_mask;
        __u64 unimpl_pa_mask;
        __u64 ptce_base;
        __u32 ptce_count[2];
        __u32 ptce_stride[2];
        struct task_struct *ksoftirqd;

        int cpu;
        __u64 loops_per_jiffy;
        __u64 ipi_count;
        __u64 prof_counter;
        __u64 prof_multiplier;
        __u64 ipi_operation;







        __u64 platform_specific;
} __attribute__ ((aligned ((1UL << 14)))) ;
# 314 "/data1/src/linux/include/asm/processor.h"
  extern struct cpuinfo_ia64 _cpu_data[32];



extern void identify_cpu (struct cpuinfo_ia64 *);
extern void print_cpu_info (struct cpuinfo_ia64 *);

typedef struct {
        unsigned long seg;
} mm_segment_t;
# 349 "/data1/src/linux/include/asm/processor.h"
struct siginfo;

struct thread_struct {
        __u64 ksp;
        unsigned long flags;
        __u64 map_base;
        __u64 task_size;
        struct siginfo *siginfo;


        __u64 eflag;
        __u64 fsr;
        __u64 fcr;
        __u64 fir;
        __u64 fdr;
        __u64 csd;
        __u64 ssd;
        __u64 old_k1;
        __u64 old_iob;





        __u64 pmc[32];
        __u64 pmd[32];
        unsigned long pfm_must_block;
        void *pfm_context;
        atomic_t pfm_notifiers_check;




        __u64 dbr[8];
        __u64 ibr[8];
        struct ia64_fpreg fph[96];
};
# 444 "/data1/src/linux/include/asm/processor.h"
struct mm_struct;
struct task_struct;







  extern void release_thread (struct task_struct *task);
# 472 "/data1/src/linux/include/asm/processor.h"
extern int kernel_thread (int (*fn)(void *), void *arg, unsigned long flags);






extern unsigned long get_wchan (struct task_struct *p);
# 491 "/data1/src/linux/include/asm/processor.h"
static inline unsigned long
ia64_get_kr (unsigned long regnum)
{
        unsigned long r;

        switch (regnum) {
              case 0: asm volatile ("mov %0=ar.k0" : "=r"(r)); break;
              case 1: asm volatile ("mov %0=ar.k1" : "=r"(r)); break;
              case 2: asm volatile ("mov %0=ar.k2" : "=r"(r)); break;
              case 3: asm volatile ("mov %0=ar.k3" : "=r"(r)); break;
              case 4: asm volatile ("mov %0=ar.k4" : "=r"(r)); break;
              case 5: asm volatile ("mov %0=ar.k5" : "=r"(r)); break;
              case 6: asm volatile ("mov %0=ar.k6" : "=r"(r)); break;
              case 7: asm volatile ("mov %0=ar.k7" : "=r"(r)); break;
        }
        return r;
}

static inline void
ia64_set_kr (unsigned long regnum, unsigned long r)
{
        switch (regnum) {
              case 0: asm volatile ("mov ar.k0=%0" :: "r"(r)); break;
              case 1: asm volatile ("mov ar.k1=%0" :: "r"(r)); break;
              case 2: asm volatile ("mov ar.k2=%0" :: "r"(r)); break;
              case 3: asm volatile ("mov ar.k3=%0" :: "r"(r)); break;
              case 4: asm volatile ("mov ar.k4=%0" :: "r"(r)); break;
              case 5: asm volatile ("mov ar.k5=%0" :: "r"(r)); break;
              case 6: asm volatile ("mov ar.k6=%0" :: "r"(r)); break;
              case 7: asm volatile ("mov ar.k7=%0" :: "r"(r)); break;
        }
}
# 540 "/data1/src/linux/include/asm/processor.h"
extern void __ia64_init_fpu (void);
extern void __ia64_save_fpu (struct ia64_fpreg *fph);
extern void __ia64_load_fpu (struct ia64_fpreg *fph);
extern void ia64_save_debug_regs (unsigned long *save_area);
extern void ia64_load_debug_regs (unsigned long *save_area);


extern void ia32_save_state (struct task_struct *task);
extern void ia32_load_state (struct task_struct *task);



extern void ia64_save_pm_regs (struct task_struct *task);
extern void ia64_load_pm_regs (struct task_struct *task);






static inline void
ia64_init_fpu (void) {
        asm volatile (";; rsm psr.dfh;; srlz.d;;" ::: "memory");;
        __ia64_init_fpu();
        asm volatile (";; ssm psr.dfh;; srlz.d;;" ::: "memory");;
}


static inline void
ia64_save_fpu (struct ia64_fpreg *fph) {
        asm volatile (";; rsm psr.dfh;; srlz.d;;" ::: "memory");;
        __ia64_save_fpu(fph);
        asm volatile (";; ssm psr.dfh;; srlz.d;;" ::: "memory");;
}


static inline void
ia64_load_fpu (struct ia64_fpreg *fph) {
        asm volatile (";; rsm psr.dfh;; srlz.d;;" ::: "memory");;
        __ia64_load_fpu(fph);
        asm volatile (";; ssm psr.dfh;; srlz.d;;" ::: "memory");;
}

static inline void
ia64_fc (void *addr)
{
        asm volatile ("fc %0" :: "r"(addr) : "memory");
}

static inline void
ia64_sync_i (void)
{
        asm volatile (";; sync.i" ::: "memory");
}

static inline void
ia64_srlz_i (void)
{
        asm volatile (";; srlz.i ;;" ::: "memory");
}

static inline void
ia64_srlz_d (void)
{
        asm volatile (";; srlz.d" ::: "memory");
}

static inline __u64
ia64_get_rr (__u64 reg_bits)
{
        __u64 r;
        asm volatile ("mov %0=rr[%1]" : "=r"(r) : "r"(reg_bits) : "memory");
        return r;
}

static inline void
ia64_set_rr (__u64 reg_bits, __u64 rr_val)
{
        asm volatile ("mov rr[%0]=%1" :: "r"(reg_bits), "r"(rr_val) : "memory");
}

static inline __u64
ia64_get_dcr (void)
{
        __u64 r;
        asm volatile ("mov %0=cr.dcr" : "=r"(r));
        return r;
}

static inline void
ia64_set_dcr (__u64 val)
{
        asm volatile ("mov cr.dcr=%0;;" :: "r"(val) : "memory");
        ia64_srlz_d();
}

static inline __u64
ia64_get_lid (void)
{
        __u64 r;
        asm volatile ("mov %0=cr.lid" : "=r"(r));
        return r;
}

static inline void
ia64_invala (void)
{
        asm volatile ("invala" ::: "memory");
}
# 663 "/data1/src/linux/include/asm/processor.h"
static inline void
ia64_itr (__u64 target_mask, __u64 tr_num,
          __u64 vmaddr, __u64 pte,
          __u64 log_page_size)
{
        asm volatile ("mov cr.itir=%0" :: "r"(log_page_size << 2) : "memory");
        asm volatile ("mov cr.ifa=%0;;" :: "r"(vmaddr) : "memory");
        if (target_mask & 0x1)
                asm volatile ("itr.i itr[%0]=%1"
                                      :: "r"(tr_num), "r"(pte) : "memory");
        if (target_mask & 0x2)
                asm volatile (";;itr.d dtr[%0]=%1"
                                      :: "r"(tr_num), "r"(pte) : "memory");
}





static inline void
ia64_itc (__u64 target_mask, __u64 vmaddr, __u64 pte,
          __u64 log_page_size)
{
        asm volatile ("mov cr.itir=%0" :: "r"(log_page_size << 2) : "memory");
        asm volatile ("mov cr.ifa=%0;;" :: "r"(vmaddr) : "memory");

        if (target_mask & 0x1)
                asm volatile ("itc.i %0;;" :: "r"(pte) : "memory");
        if (target_mask & 0x2)
                asm volatile (";;itc.d %0;;" :: "r"(pte) : "memory");
}





static inline void
ia64_ptr (__u64 target_mask, __u64 vmaddr, __u64 log_size)
{
        if (target_mask & 0x1)
                asm volatile ("ptr.i %0,%1" :: "r"(vmaddr), "r"(log_size << 2));
        if (target_mask & 0x2)
                asm volatile ("ptr.d %0,%1" :: "r"(vmaddr), "r"(log_size << 2));
}


static inline void
ia64_set_iva (void *ivt_addr)
{
        asm volatile ("mov cr.iva=%0;; srlz.i;;" :: "r"(ivt_addr) : "memory");
}


static inline void
ia64_set_pta (__u64 pta)
{

        asm volatile ("mov cr.pta=%0;; srlz.i;;" :: "r"(pta) : "memory");
}

static inline __u64
ia64_get_cpuid (__u64 regnum)
{
        __u64 r;

        asm ("mov %0=cpuid[%r1]" : "=r"(r) : "rO"(regnum));
        return r;
}

static inline void
ia64_eoi (void)
{
        asm ("mov cr.eoi=r0;; srlz.d;;" ::: "memory");
}

static inline void
ia64_set_lrr0 (unsigned long val)
{
        asm volatile ("mov cr.lrr0=%0;; srlz.d" :: "r"(val) : "memory");
}




static inline void
ia64_set_lrr1 (unsigned long val)
{
        asm volatile ("mov cr.lrr1=%0;; srlz.d" :: "r"(val) : "memory");
}

static inline void
ia64_set_pmv (__u64 val)
{
        asm volatile ("mov cr.pmv=%0" :: "r"(val) : "memory");
}

static inline __u64
ia64_get_pmc (__u64 regnum)
{
        __u64 retval;

        asm volatile ("mov %0=pmc[%1]" : "=r"(retval) : "r"(regnum));
        return retval;
}

static inline void
ia64_set_pmc (__u64 regnum, __u64 value)
{
        asm volatile ("mov pmc[%0]=%1" :: "r"(regnum), "r"(value));
}

static inline __u64
ia64_get_pmd (__u64 regnum)
{
        __u64 retval;

        asm volatile ("mov %0=pmd[%1]" : "=r"(retval) : "r"(regnum));
        return retval;
}

static inline void
ia64_set_pmd (__u64 regnum, __u64 value)
{
        asm volatile ("mov pmd[%0]=%1" :: "r"(regnum), "r"(value));
}





static inline __u64
ia64_unat_pos (void *spill_addr)
{
        return ((__u64) spill_addr >> 3) & 0x3f;
}





static inline void
ia64_set_unat (__u64 *unat, void *spill_addr, unsigned long nat)
{
        __u64 bit = ia64_unat_pos(spill_addr);
        __u64 mask = 1UL << bit;

        *unat = (*unat & ~mask) | (nat << bit);
}





static inline unsigned long
thread_saved_pc (struct thread_struct *t)
{
        struct unw_frame_info info;
        unsigned long ip;


        struct task_struct *p = (void *) ((unsigned long) t - 1488);

        unw_init_from_blocked_task(&info, p);
        if (unw_unwind(&info) < 0)
                return 0;
        unw_get_ip(&info, &ip);
        return ip;
}
# 851 "/data1/src/linux/include/asm/processor.h"
static inline void
ia64_set_cmcv (__u64 val)
{
        asm volatile ("mov cr.cmcv=%0" :: "r"(val) : "memory");
}




static inline __u64
ia64_get_cmcv (void)
{
        __u64 val;

        asm volatile ("mov %0=cr.cmcv" : "=r"(val) :: "memory");
        return val;
}

static inline __u64
ia64_get_ivr (void)
{
        __u64 r;
        asm volatile ("srlz.d;; mov %0=cr.ivr;; srlz.d;;" : "=r"(r));
        return r;
}

static inline void
ia64_set_tpr (__u64 val)
{
        asm volatile ("mov cr.tpr=%0" :: "r"(val));
}

static inline __u64
ia64_get_tpr (void)
{
        __u64 r;
        asm volatile ("mov %0=cr.tpr" : "=r"(r));
        return r;
}

static inline void
ia64_set_irr0 (__u64 val)
{
        asm volatile("mov cr.irr0=%0;;" :: "r"(val) : "memory");
        ia64_srlz_d();
}

static inline __u64
ia64_get_irr0 (void)
{
        __u64 val;


        asm volatile("mov %0=cr.irr0" : "=r"(val));
        return val;
}

static inline void
ia64_set_irr1 (__u64 val)
{
        asm volatile("mov cr.irr1=%0;;" :: "r"(val) : "memory");
        ia64_srlz_d();
}

static inline __u64
ia64_get_irr1 (void)
{
        __u64 val;


        asm volatile("mov %0=cr.irr1" : "=r"(val));
        return val;
}

static inline void
ia64_set_irr2 (__u64 val)
{
        asm volatile("mov cr.irr2=%0;;" :: "r"(val) : "memory");
        ia64_srlz_d();
}

static inline __u64
ia64_get_irr2 (void)
{
        __u64 val;


        asm volatile("mov %0=cr.irr2" : "=r"(val));
        return val;
}

static inline void
ia64_set_irr3 (__u64 val)
{
        asm volatile("mov cr.irr3=%0;;" :: "r"(val) : "memory");
        ia64_srlz_d();
}

static inline __u64
ia64_get_irr3 (void)
{
        __u64 val;


        asm volatile ("mov %0=cr.irr3" : "=r"(val));
        return val;
}

static inline __u64
ia64_get_gp(void)
{
        __u64 val;

        asm ("mov %0=gp" : "=r"(val));
        return val;
}

static inline void
ia64_set_ibr (__u64 regnum, __u64 value)
{
        asm volatile ("mov ibr[%0]=%1" :: "r"(regnum), "r"(value));
}

static inline void
ia64_set_dbr (__u64 regnum, __u64 value)
{
        asm volatile ("mov dbr[%0]=%1" :: "r"(regnum), "r"(value));

        asm volatile (";; srlz.d");

}

static inline __u64
ia64_get_ibr (__u64 regnum)
{
        __u64 retval;

        asm volatile ("mov %0=ibr[%1]" : "=r"(retval) : "r"(regnum));
        return retval;
}

static inline __u64
ia64_get_dbr (__u64 regnum)
{
        __u64 retval;

        asm volatile ("mov %0=dbr[%1]" : "=r"(retval) : "r"(regnum));

        asm volatile (";; srlz.d");

        return retval;
}
# 1023 "/data1/src/linux/include/asm/processor.h"
static inline __u64
ia64_thash (__u64 addr)
{
        __u64 result;
        asm ("thash %0=%1" : "=r"(result) : "r" (addr));
        return result;
}

static inline __u64
ia64_tpa (__u64 addr)
{
        __u64 result;
        asm ("tpa %0=%1" : "=r"(result) : "r"(addr));
        return result;
}






extern inline void
prefetch (const void *x)
{
         __asm__ __volatile__ ("lfetch [%0]" : : "r"(x));
}

extern inline void
prefetchw (const void *x)
{
        __asm__ __volatile__ ("lfetch.excl [%0]" : : "r"(x));
}
# 14 "/data1/src/linux/include/linux/prefetch.h" 2
# 1 "/data1/src/linux/include/asm/cache.h" 1
# 15 "/data1/src/linux/include/linux/prefetch.h" 2
# 7 "/data1/src/linux/include/linux/list.h" 2
# 18 "/data1/src/linux/include/linux/list.h"
struct list_head {
        struct list_head *next, *prev;
};

typedef struct list_head list_t;
# 39 "/data1/src/linux/include/linux/list.h"
static __inline__ void __list_add(struct list_head * new,
        struct list_head * prev,
        struct list_head * next)
{
        next->prev = new;
        new->next = next;
        new->prev = prev;
        prev->next = new;
}
# 57 "/data1/src/linux/include/linux/list.h"
static __inline__ void list_add(struct list_head *new, struct list_head *head)
{
        __list_add(new, head, head->next);
}
# 70 "/data1/src/linux/include/linux/list.h"
static __inline__ void list_add_tail(struct list_head *new, struct list_head *head)
{
        __list_add(new, head->prev, head);
}
# 82 "/data1/src/linux/include/linux/list.h"
static __inline__ void __list_del(struct list_head * prev,
                                  struct list_head * next)
{
        next->prev = prev;
        prev->next = next;
}






static __inline__ void list_del(struct list_head *entry)
{
        __list_del(entry->prev, entry->next);
}





static __inline__ void list_del_init(struct list_head *entry)
{
        __list_del(entry->prev, entry->next);
        do { (entry)->next = (entry); (entry)->prev = (entry); } while (0);
}





static __inline__ int list_empty(struct list_head *head)
{
        return head->next == head;
}






static __inline__ void list_splice(struct list_head *list, struct list_head *head)
{
        struct list_head *first = list->next;

        if (first != list) {
                struct list_head *last = list->prev;
                struct list_head *at = head->next;

                first->prev = head;
                head->next = first;

                last->next = at;
                at->prev = last;
        }
}
# 15 "/data1/src/linux/include/linux/wait.h" 2

# 1 "/data1/src/linux/include/linux/spinlock.h" 1
# 39 "/data1/src/linux/include/linux/spinlock.h"
# 1 "/data1/src/linux/include/asm/spinlock.h" 1
# 15 "/data1/src/linux/include/asm/spinlock.h"
# 1 "/data1/src/linux/include/asm/bitops.h" 1
# 10 "/data1/src/linux/include/asm/bitops.h"
# 1 "/data1/src/linux/include/linux/sched_param.h" 1
# 11 "/data1/src/linux/include/asm/bitops.h" 2
# 29 "/data1/src/linux/include/asm/bitops.h"
static __inline__ void
set_bit (int nr, volatile void *addr)
{
        __u32 bit, old, new;
        volatile __u32 *m;
       

        m = (volatile __u32 *) addr + (nr >> 5);
        bit = 1 << (nr & 31);
        do {
                ;
                old = *m;
                new = old | bit;
        } while (({ __typeof__((m)) _p_ = ((m)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*(m))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (long) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*(m))) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
}
# 54 "/data1/src/linux/include/asm/bitops.h"
static __inline__ void
__set_bit (int nr, volatile void *addr)
{
        *((__u32 *) addr + (nr >> 5)) |= (1 << (nr & 31));
}
# 76 "/data1/src/linux/include/asm/bitops.h"
static __inline__ void
clear_bit (int nr, volatile void *addr)
{
        __u32 mask, old, new;
        volatile __u32 *m;
       

        m = (volatile __u32 *) addr + (nr >> 5);
        mask = ~(1 << (nr & 31));
        do {
                ;
                old = *m;
                new = old & mask;
        } while (({ __typeof__((m)) _p_ = ((m)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*(m))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (long) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*(m))) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
}




static __inline__ void
__clear_bit (int nr, volatile void *addr)
{
        volatile __u32 *p = (__u32 *) addr + (nr >> 5);;
        __u32 m = 1 << (nr & 31);
        *p &= ~m;
}
# 112 "/data1/src/linux/include/asm/bitops.h"
static __inline__ void
change_bit (int nr, volatile void *addr)
{
        __u32 bit, old, new;
        volatile __u32 *m;
       

        m = (volatile __u32 *) addr + (nr >> 5);
        bit = (1 << (nr & 31));
        do {
                ;
                old = *m;
                new = old ^ bit;
        } while (({ __typeof__((m)) _p_ = ((m)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*(m))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (long) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*(m))) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
}
# 137 "/data1/src/linux/include/asm/bitops.h"
static __inline__ void
__change_bit (int nr, volatile void *addr)
{
        *((__u32 *) addr + (nr >> 5)) ^= (1 << (nr & 31));
}
# 151 "/data1/src/linux/include/asm/bitops.h"
static __inline__ int
test_and_set_bit (int nr, volatile void *addr)
{
        __u32 bit, old, new;
        volatile __u32 *m;
       

        m = (volatile __u32 *) addr + (nr >> 5);
        bit = 1 << (nr & 31);
        do {
                ;
                old = *m;
                new = old | bit;
        } while (({ __typeof__((m)) _p_ = ((m)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*(m))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (long) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*(m))) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
        return (old & bit) != 0;
}
# 177 "/data1/src/linux/include/asm/bitops.h"
static __inline__ int
__test_and_set_bit (int nr, volatile void *addr)
{
        __u32 *p = (__u32 *) addr + (nr >> 5);
        __u32 m = 1 << (nr & 31);
        int oldbitset = (*p & m) != 0;

        *p |= m;
        return oldbitset;
}
# 196 "/data1/src/linux/include/asm/bitops.h"
static __inline__ int
test_and_clear_bit (int nr, volatile void *addr)
{
        __u32 mask, old, new;
        volatile __u32 *m;
       

        m = (volatile __u32 *) addr + (nr >> 5);
        mask = ~(1 << (nr & 31));
        do {
                ;
                old = *m;
                new = old & mask;
        } while (({ __typeof__((m)) _p_ = ((m)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*(m))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (long) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*(m))) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
        return (old & ~mask) != 0;
}
# 222 "/data1/src/linux/include/asm/bitops.h"
static __inline__ int
__test_and_clear_bit(int nr, volatile void * addr)
{
        __u32 *p = (__u32 *) addr + (nr >> 5);
        __u32 m = 1 << (nr & 31);
        int oldbitset = *p & m;

        *p &= ~m;
        return oldbitset;
}
# 241 "/data1/src/linux/include/asm/bitops.h"
static __inline__ int
test_and_change_bit (int nr, volatile void *addr)
{
        __u32 bit, old, new;
        volatile __u32 *m;
       

        m = (volatile __u32 *) addr + (nr >> 5);
        bit = (1 << (nr & 31));
        do {
                ;
                old = *m;
                new = old ^ bit;
        } while (({ __typeof__((m)) _p_ = ((m)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*(m))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (long) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*(m))) { case 1: __asm__ __volatile__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_called_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
        return (old & bit) != 0;
}




static __inline__ int
__test_and_change_bit (int nr, void *addr)
{
        __u32 old, bit = (1 << (nr & 31));
        __u32 *m = (__u32 *) addr + (nr >> 5);

        old = *m;
        *m = old ^ bit;
        return (old & bit) != 0;
}

static __inline__ int
test_bit (int nr, volatile void *addr)
{
        return 1 & (((const volatile __u32 *) addr)[nr >> 5] >> (nr & 31));
}
# 286 "/data1/src/linux/include/asm/bitops.h"
static inline unsigned long
ffz (unsigned long x)
{
        unsigned long result;

        __asm__ ("popcnt %0=%1" : "=r" (result) : "r" (x & (~x - 1)));
        return result;
}







static inline unsigned long
ia64_fls (unsigned long x)
{
        double d = x;
        long exp;

        __asm__ ("getf.exp %0=%1" : "=r"(exp) : "f"(d));
        return exp - 0xffff;
}
# 323 "/data1/src/linux/include/asm/bitops.h"
static __inline__ unsigned long
hweight64 (unsigned long x)
{
        unsigned long result;
        __asm__ ("popcnt %0=%1" : "=r" (result) : "r" (x));
        return result;
}
# 340 "/data1/src/linux/include/asm/bitops.h"
static inline int
find_next_zero_bit (void *addr, unsigned long size, unsigned long offset)
{
        unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
        unsigned long result = offset & ~63UL;
        unsigned long tmp;

        if (offset >= size)
                return size;
        size -= result;
        offset &= 63UL;
        if (offset) {
                tmp = *(p++);
                tmp |= ~0UL >> (64-offset);
                if (size < 64)
                        goto found_first;
                if (~tmp)
                        goto found_middle;
                size -= 64;
                result += 64;
        }
        while (size & ~63UL) {
                if (~(tmp = *(p++)))
                        goto found_middle;
                result += 64;
                size -= 64;
        }
        if (!size)
                return result;
        tmp = *p;
found_first:
        tmp |= ~0UL << size;
found_middle:
        return result + ffz(tmp);
}
# 405 "/data1/src/linux/include/asm/bitops.h"
static inline int
sched_find_first_zero_bit (char *bitmap)
{




        u64 *b = (u64 *) bitmap;
        u64 rt;

        rt = b[0] & b[1];
        if (__builtin_expect((rt != 0xffffffffffffffff),0))
                return find_next_zero_bit((bitmap), (128), 0);

        return ffz(b[2]) + 128;
}
# 16 "/data1/src/linux/include/asm/spinlock.h" 2
# 70 "/data1/src/linux/include/asm/spinlock.h"
typedef struct {
        volatile unsigned int lock;
} spinlock_t;
# 105 "/data1/src/linux/include/asm/spinlock.h"
typedef struct {
        volatile int read_counter:31;
        volatile int write_lock:1;
} rwlock_t;
# 40 "/data1/src/linux/include/linux/spinlock.h" 2
# 138 "/data1/src/linux/include/linux/spinlock.h"
extern int atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
# 17 "/data1/src/linux/include/linux/wait.h" 2





struct __wait_queue {
        unsigned int flags;

        struct task_struct * task;
        struct list_head task_list;
};
typedef struct __wait_queue wait_queue_t;
# 64 "/data1/src/linux/include/linux/wait.h"
struct __wait_queue_head {
        spinlock_t lock;
        struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
# 89 "/data1/src/linux/include/linux/wait.h"
static inline void init_waitqueue_head(wait_queue_head_t *q)
{
        q->lock = (spinlock_t) { 0 };
        do { (&q->task_list)->next = (&q->task_list); (&q->task_list)->prev = (&q->task_list); } while (0);
}

static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
{
        q->flags = 0;
        q->task = p;
}

static inline int waitqueue_active(wait_queue_head_t *q)
{
        return !list_empty(&q->task_list);
}

static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
{
        list_add(&new->task_list, &head->task_list);
}




static inline void __add_wait_queue_tail(wait_queue_head_t *head,
                                                wait_queue_t *new)
{
        list_add_tail(&new->task_list, &head->task_list);
}

static inline void __remove_wait_queue(wait_queue_head_t *head,
                                                        wait_queue_t *old)
{
        list_del(&old->task_list);
}
# 13 "/data1/src/linux/include/linux/fs.h" 2

# 1 "/data1/src/linux/include/linux/vfs.h" 1



# 1 "/data1/src/linux/include/asm/statfs.h" 1
# 11 "/data1/src/linux/include/asm/statfs.h"
   typedef __kernel_fsid_t fsid_t;


struct statfs {
        long f_type;
        long f_bsize;
        long f_blocks;
        long f_bfree;
        long f_bavail;
        long f_files;
        long f_ffree;
        __kernel_fsid_t f_fsid;
        long f_namelen;
        long f_spare[6];
};
# 5 "/data1/src/linux/include/linux/vfs.h" 2
# 15 "/data1/src/linux/include/linux/fs.h" 2
# 1 "/data1/src/linux/include/linux/net.h" 1
# 22 "/data1/src/linux/include/linux/net.h"
# 1 "/data1/src/linux/include/linux/socket.h" 1





# 1 "/data1/src/linux/include/asm/socket.h" 1
# 11 "/data1/src/linux/include/asm/socket.h"
# 1 "/data1/src/linux/include/asm/sockios.h" 1
# 12 "/data1/src/linux/include/asm/socket.h" 2
# 7 "/data1/src/linux/include/linux/socket.h" 2
# 1 "/data1/src/linux/include/linux/sockios.h" 1
# 8 "/data1/src/linux/include/linux/socket.h" 2
# 1 "/data1/src/linux/include/linux/uio.h" 1
# 19 "/data1/src/linux/include/linux/uio.h"
struct iovec
{
        void *iov_base;
        __kernel_size_t iov_len;
};
# 9 "/data1/src/linux/include/linux/socket.h" 2


typedef unsigned short sa_family_t;





struct sockaddr {
        sa_family_t sa_family;
        char sa_data[14];
};

struct linger {
        int l_onoff;
        int l_linger;
};







struct msghdr {
        void * msg_name;
        int msg_namelen;
        struct iovec * msg_iov;
        __kernel_size_t msg_iovlen;
        void * msg_control;
        __kernel_size_t msg_controllen;
        unsigned msg_flags;
};







struct cmsghdr {
        __kernel_size_t cmsg_len;
        int cmsg_level;
        int cmsg_type;
};
# 102 "/data1/src/linux/include/linux/socket.h"
static inline struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,
                                               struct cmsghdr *__cmsg)
{
        struct cmsghdr * __ptr;

        __ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) + ( ((__cmsg->cmsg_len)+sizeof(long)-1) & ~(sizeof(long)-1) ));
        if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
                return (struct cmsghdr *)0;

        return __ptr;
}

static inline struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)
{
        return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
}







struct ucred {
        __u32 pid;
        __u32 uid;
        __u32 gid;
};
# 249 "/data1/src/linux/include/linux/socket.h"
extern int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
extern int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov,
                                int offset, int len);
extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
                                          struct iovec *iov,
                                          int offset,
                                          unsigned int len, int *csump);

extern int verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode);
extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
extern void memcpy_tokerneliovec(struct iovec *iov, unsigned char *kdata, int len);
extern int move_addr_to_user(void *kaddr, int klen, void *uaddr, int *ulen);
extern int move_addr_to_kernel(void *uaddr, int ulen, void *kaddr);
extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
# 23 "/data1/src/linux/include/linux/net.h" 2


struct poll_table_struct;
# 49 "/data1/src/linux/include/linux/net.h"
typedef enum {
  SS_FREE = 0,
  SS_UNCONNECTED,
  SS_CONNECTING,
  SS_CONNECTED,
  SS_DISCONNECTING
} socket_state;
# 65 "/data1/src/linux/include/linux/net.h"
struct socket
{
        socket_state state;

        unsigned long flags;
        struct proto_ops *ops;
        struct inode *inode;
        struct fasync_struct *fasync_list;
        struct file *file;
        struct sock *sk;
        wait_queue_head_t wait;

        short type;
        unsigned char passcred;
};



struct scm_cookie;
struct vm_area_struct;
struct page;

struct proto_ops {
  int family;

  int (*release) (struct socket *sock);
  int (*bind) (struct socket *sock, struct sockaddr *umyaddr,
                         int sockaddr_len);
  int (*connect) (struct socket *sock, struct sockaddr *uservaddr,
                         int sockaddr_len, int flags);
  int (*socketpair) (struct socket *sock1, struct socket *sock2);
  int (*accept) (struct socket *sock, struct socket *newsock,
                         int flags);
  int (*getname) (struct socket *sock, struct sockaddr *uaddr,
                         int *usockaddr_len, int peer);
  unsigned int (*poll) (struct file *file, struct socket *sock, struct poll_table_struct *wait);
  int (*ioctl) (struct socket *sock, unsigned int cmd,
                         unsigned long arg);
  int (*listen) (struct socket *sock, int len);
  int (*shutdown) (struct socket *sock, int flags);
  int (*setsockopt) (struct socket *sock, int level, int optname,
                         char *optval, int optlen);
  int (*getsockopt) (struct socket *sock, int level, int optname,
                         char *optval, int *optlen);
  int (*sendmsg) (struct socket *sock, struct msghdr *m, int total_len, struct scm_cookie *scm);
  int (*recvmsg) (struct socket *sock, struct msghdr *m, int total_len, int flags, struct scm_cookie *scm);
  int (*mmap) (struct file *file, struct socket *sock, struct vm_area_struct * vma);
  ssize_t (*sendpage) (struct socket *sock, struct page *page, int offset, size_t size, int flags);
};

struct net_proto_family
{
        int family;
        int (*create)(struct socket *sock, int protocol);


        short authentication;
        short encryption;
        short encrypt_net;
};

struct net_proto
{
        const char *name;
        void (*init_func)(struct net_proto *);
};

extern int sock_wake_async(struct socket *sk, int how, int band);
extern int sock_register(struct net_proto_family *fam);
extern int sock_unregister(int family);
extern struct socket *sock_alloc(void);
extern int sock_create(int family, int type, int proto, struct socket **);
extern void sock_release(struct socket *);
extern int sock_sendmsg(struct socket *, struct msghdr *m, int len);
extern int sock_recvmsg(struct socket *, struct msghdr *m, int len, int flags);
extern int sock_readv_writev(int type, struct inode * inode, struct file * file,
                                  const struct iovec * iov, long count, long size);

extern int net_ratelimit(void);
extern unsigned long net_random(void);
extern void net_srandom(unsigned long);
# 16 "/data1/src/linux/include/linux/fs.h" 2
# 1 "/data1/src/linux/include/linux/kdev_t.h" 1
# 73 "/data1/src/linux/include/linux/kdev_t.h"
typedef struct {
        unsigned short value;
} kdev_t;
# 89 "/data1/src/linux/include/linux/kdev_t.h"
static inline unsigned int kdev_val(kdev_t dev)
{
        return dev.value;
}

static inline kdev_t val_to_kdev(unsigned int val)
{
        kdev_t dev;
        dev.value = val;
        return dev;
}





extern const char * kdevname(kdev_t);

static inline int kdev_same(kdev_t dev1, kdev_t dev2)
{
        return dev1.value == dev2.value;
}
# 130 "/data1/src/linux/include/linux/kdev_t.h"
static inline int kdev_t_to_nr(kdev_t dev)
{
        return ((((((dev).value >> 8) & 0xff)) << 8) | (((dev).value & 0xff)));
}

static inline kdev_t to_kdev_t(int dev)
{
        return ((kdev_t) { (((((unsigned int) ((dev) >> 8))) << 8) + (((unsigned int) ((dev) & ((1U << 8) - 1))))) } );
}
# 17 "/data1/src/linux/include/linux/fs.h" 2
# 1 "/data1/src/linux/include/linux/ioctl.h" 1



# 1 "/data1/src/linux/include/asm/ioctl.h" 1
# 5 "/data1/src/linux/include/linux/ioctl.h" 2
# 18 "/data1/src/linux/include/linux/fs.h" 2

# 1 "/data1/src/linux/include/linux/dcache.h" 1






# 1 "/data1/src/linux/include/linux/mount.h" 1
# 19 "/data1/src/linux/include/linux/mount.h"
struct vfsmount
{
        struct list_head mnt_hash;
        struct vfsmount *mnt_parent;
        struct dentry *mnt_mountpoint;
        struct dentry *mnt_root;
        struct super_block *mnt_sb;
        struct list_head mnt_mounts;
        struct list_head mnt_child;
        atomic_t mnt_count;
        int mnt_flags;
        char *mnt_devname;
        struct list_head mnt_list;
};

static inline struct vfsmount *mntget(struct vfsmount *mnt)
{
        if (mnt)
                ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&mnt->mnt_count)))->counter)) *_v = (&(((&mnt->mnt_count)))->counter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case !
-4: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia6!
4_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&mnt->mnt_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); !
break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&mnt->mnt_count)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&mnt->mnt_count))));
        return mnt;
}

extern void __mntput(struct vfsmount *mnt);

static inline void mntput(struct vfsmount *mnt)
{
        if (mnt) {
                if ((((__builtin_constant_p(1) && ( (1 == 1) || (1 == 4) || (1 == 8) || (1 == 16) || (1 == -1) || (1 == -4) || (1 == -8) || (1 == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&((&mnt->mnt_count))->counter)) *_v = (&((&mnt->mnt_count))->counter); switch (-(1)) { case -16: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeo!
f(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); b!
reak; case 4: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&((&mnt->mnt_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_i!
a64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&((&mnt->mnt_count))->counter)) (_tmp + (-(1))); }) : ia64_atomic_sub(1, (&mnt->mnt_count))) == 0))
                        __mntput(mnt);
        }
}
# 8 "/data1/src/linux/include/linux/dcache.h" 2
# 24 "/data1/src/linux/include/linux/dcache.h"
struct qstr {
        const unsigned char * name;
        unsigned int len;
        unsigned int hash;
};

struct dentry_stat_t {
        int nr_dentry;
        int nr_unused;
        int age_limit;
        int want_pages;
        int dummy[2];
};
extern struct dentry_stat_t dentry_stat;






static __inline__ unsigned long partial_name_hash(unsigned long c, unsigned long prevhash)
{
        return (prevhash + (c << 4) + (c >> 4)) * 11;
}


static __inline__ unsigned long end_name_hash(unsigned long hash)
{
        return (unsigned int) hash;
}


static __inline__ unsigned int full_name_hash(const unsigned char * name, unsigned int len)
{
        unsigned long hash = 0;
        while (len--)
                hash = partial_name_hash(*name++, hash);
        return end_name_hash(hash);
}



struct dentry {
        atomic_t d_count;
        unsigned int d_flags;
        struct inode * d_inode;
        struct dentry * d_parent;
        struct list_head d_hash;
        struct list_head d_lru;
        struct list_head d_child;
        struct list_head d_subdirs;
        struct list_head d_alias;
        int d_mounted;
        struct qstr d_name;
        unsigned long d_time;
        struct dentry_operations *d_op;
        struct super_block * d_sb;
        unsigned long d_vfs_flags;
        void * d_fsdata;
        unsigned char d_iname[16];
};

struct dentry_operations {
        int (*d_revalidate)(struct dentry *, int);
        int (*d_hash) (struct dentry *, struct qstr *);
        int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
        int (*d_delete)(struct dentry *);
        void (*d_release)(struct dentry *);
        void (*d_iput)(struct dentry *, struct inode *);
};
# 127 "/data1/src/linux/include/linux/dcache.h"
extern spinlock_t dcache_lock;
# 146 "/data1/src/linux/include/linux/dcache.h"
static __inline__ void d_drop(struct dentry * dentry)
{
        __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&dcache_lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
        list_del(&dentry->d_hash);
        do { (&dentry->d_hash)->next = (&dentry->d_hash); (&dentry->d_hash)->prev = (&dentry->d_hash); } while (0);
        do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &dcache_lock)->lock = 0; } while (0);
}

static __inline__ int dname_external(struct dentry *d)
{
        return d->d_name.name != d->d_iname;
}




extern void d_instantiate(struct dentry *, struct inode *);
extern void d_delete(struct dentry *);


extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
extern void shrink_dcache_sb(struct super_block *);
extern void shrink_dcache_parent(struct dentry *);
extern int d_invalidate(struct dentry *);


struct zone_struct;

extern int shrink_dcache_memory(int, unsigned int);
extern void prune_dcache(int);


extern int shrink_icache_memory(int, int);
extern void prune_icache(int);


extern int shrink_dqcache_memory(int, unsigned int);


extern struct dentry * d_alloc_root(struct inode *);


extern void d_genocide(struct dentry *);

extern struct dentry *d_find_alias(struct inode *);
extern void d_prune_aliases(struct inode *);


extern int have_submounts(struct dentry *);




extern void d_rehash(struct dentry *);
# 210 "/data1/src/linux/include/linux/dcache.h"
static __inline__ void d_add(struct dentry * entry, struct inode * inode)
{
        d_instantiate(entry, inode);
        d_rehash(entry);
}


extern void d_move(struct dentry *, struct dentry *);


extern struct dentry * d_lookup(struct dentry *, struct qstr *);


extern int d_validate(struct dentry *, struct dentry *);

extern char * __d_path(struct dentry *, struct vfsmount *, struct dentry *,
        struct vfsmount *, char *, int);
# 243 "/data1/src/linux/include/linux/dcache.h"
static __inline__ struct dentry * dget(struct dentry *dentry)
{
        if (dentry) {
                if (!((&dentry->d_count)->counter))
                        do { printk("kernel BUG at %s:%d!\n", "/data1/src/linux/include/linux/dcache.h", 247); *(int *)0=0; } while (0);
                ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&dentry->d_count)))->counter)) *_v = (&(((&dentry->d_count)))->counter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; c!
ase -4: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_!
for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&dentry->d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&dentry-
>Release-Note:
>Audit-Trail:
>Unformatted:
 >d_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "!
 memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&dentry->d_count)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&dentry->d_count))) );
         }
         return dentry;
 }
 
 extern struct dentry * dget_locked(struct dentry *);
 # 262 "/data1/src/linux/include/linux/dcache.h"
 static __inline__ int d_unhashed(struct dentry *dentry)
 {
         return list_empty(&dentry->d_hash);
 }
 
 extern void dput(struct dentry *);
 
 static __inline__ int d_mountpoint(struct dentry *dentry)
 {
         return dentry->d_mounted;
 }
 
 extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
 # 20 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/stat.h" 1
 
 
 
 
 
 # 1 "/data1/src/linux/include/asm/stat.h" 1
 # 9 "/data1/src/linux/include/asm/stat.h"
 struct stat {
         unsigned long st_dev;
         unsigned long st_ino;
         unsigned long st_nlink;
         unsigned int st_mode;
         unsigned int st_uid;
         unsigned int st_gid;
         unsigned int __pad0;
         unsigned long st_rdev;
         unsigned long st_size;
         unsigned long st_atime;
         unsigned long __reserved0;
         unsigned long st_mtime;
         unsigned long __reserved1;
         unsigned long st_ctime;
         unsigned long __reserved2;
         unsigned long st_blksize;
         long st_blocks;
         unsigned long __unused[3];
 };
 
 struct ia64_oldstat {
         unsigned int st_dev;
         unsigned int st_ino;
         unsigned int st_mode;
         unsigned int st_nlink;
         unsigned int st_uid;
         unsigned int st_gid;
         unsigned int st_rdev;
         unsigned int __pad1;
         unsigned long st_size;
         unsigned long st_atime;
         unsigned long st_mtime;
         unsigned long st_ctime;
         unsigned int st_blksize;
         int st_blocks;
         unsigned int __unused1;
         unsigned int __unused2;
 };
 # 7 "/data1/src/linux/include/linux/stat.h" 2
 # 21 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/cache.h" 1
 # 22 "/data1/src/linux/include/linux/fs.h" 2
 
 # 1 "/data1/src/linux/include/linux/string.h" 1
 # 15 "/data1/src/linux/include/linux/string.h"
 extern char * ___strtok;
 extern char * strpbrk(const char *,const char *);
 extern char * strtok(char *,const char *);
 extern char * strsep(char **,const char *);
 extern __kernel_size_t strspn(const char *,const char *);
 
 
 
 
 
 # 1 "/data1/src/linux/include/asm/string.h" 1
 # 19 "/data1/src/linux/include/asm/string.h"
 extern __kernel_size_t strlen (const char *);
 extern void *memset (void *, int, __kernel_size_t);
 extern void *memcpy (void *, const void *, __kernel_size_t);
 # 26 "/data1/src/linux/include/linux/string.h" 2
 
 
 extern char * strcpy(char *,const char *);
 
 
 extern char * strncpy(char *,const char *, __kernel_size_t);
 
 
 extern char * strcat(char *, const char *);
 
 
 extern char * strncat(char *, const char *, __kernel_size_t);
 
 
 extern int strcmp(const char *,const char *);
 
 
 extern int strncmp(const char *,const char *,__kernel_size_t);
 
 
 extern int strnicmp(const char *, const char *, __kernel_size_t);
 
 
 extern char * strchr(const char *,int);
 
 
 extern char * strrchr(const char *,int);
 
 
 extern char * strstr(const char *,const char *);
 
 
 
 
 
 extern __kernel_size_t strnlen(const char *,__kernel_size_t);
 # 71 "/data1/src/linux/include/linux/string.h"
 extern void * memmove(void *,const void *,__kernel_size_t);
 
 
 extern void * memscan(void *,int,__kernel_size_t);
 
 
 extern int memcmp(const void *,const void *,__kernel_size_t);
 
 
 extern void * memchr(const void *,int,__kernel_size_t);
 
 extern char * kstrdup(const char *,int);
 # 24 "/data1/src/linux/include/linux/fs.h" 2
 
 
 
 
 struct poll_table_struct;
 # 50 "/data1/src/linux/include/linux/fs.h"
 struct files_stat_struct {
         int nr_files;
         int nr_free_files;
         int max_files;
 };
 extern struct files_stat_struct files_stat;
 
 struct inodes_stat_t {
         int nr_inodes;
         int nr_unused;
         int dummy[5];
 };
 extern struct inodes_stat_t inodes_stat;
 
 extern int leases_enable, dir_notify_enable, lease_break_time;
 # 202 "/data1/src/linux/include/linux/fs.h"
 # 1 "/data1/src/linux/include/asm/semaphore.h" 1
 # 10 "/data1/src/linux/include/asm/semaphore.h"
 # 1 "/data1/src/linux/include/linux/rwsem.h" 1
 # 22 "/data1/src/linux/include/linux/rwsem.h"
 struct rw_semaphore;
 
 
 # 1 "/data1/src/linux/include/linux/rwsem-spinlock.h" 1
 # 22 "/data1/src/linux/include/linux/rwsem-spinlock.h"
 struct rwsem_waiter;
 # 31 "/data1/src/linux/include/linux/rwsem-spinlock.h"
 struct rw_semaphore {
         __s32 activity;
         spinlock_t wait_lock;
         struct list_head wait_list;
 
 
 
 };
 # 55 "/data1/src/linux/include/linux/rwsem-spinlock.h"
 extern void init_rwsem(struct rw_semaphore *sem);
 extern void __down_read(struct rw_semaphore *sem);
 extern void __down_write(struct rw_semaphore *sem);
 extern void __up_read(struct rw_semaphore *sem);
 extern void __up_write(struct rw_semaphore *sem);
 # 26 "/data1/src/linux/include/linux/rwsem.h" 2
 # 41 "/data1/src/linux/include/linux/rwsem.h"
 static inline void down_read(struct rw_semaphore *sem)
 {
         ;
         __down_read(sem);
         ;
 }
 
 
 
 
 static inline void down_write(struct rw_semaphore *sem)
 {
         ;
         __down_write(sem);
         ;
 }
 
 
 
 
 static inline void up_read(struct rw_semaphore *sem)
 {
         ;
         __up_read(sem);
         ;
 }
 
 
 
 
 static inline void up_write(struct rw_semaphore *sem)
 {
         ;
         __up_write(sem);
         ;
 }
 # 11 "/data1/src/linux/include/asm/semaphore.h" 2
 
 
 
 struct semaphore {
         atomic_t count;
         int sleepers;
         wait_queue_head_t wait;
 
 
 
 };
 # 43 "/data1/src/linux/include/asm/semaphore.h"
 static inline void
 sema_init (struct semaphore *sem, int val)
 {
         *sem = (struct semaphore) { ((atomic_t) { (val) }), 0, { lock: (spinlock_t) { 0 }, task_list: { &((*sem).wait).task_list, &((*sem).wait).task_list } } };
 }
 
 static inline void
 init_MUTEX (struct semaphore *sem)
 {
         sema_init(sem, 1);
 }
 
 static inline void
 init_MUTEX_LOCKED (struct semaphore *sem)
 {
         sema_init(sem, 0);
 }
 
 extern void __down (struct semaphore * sem);
 extern int __down_interruptible (struct semaphore * sem);
 extern int __down_trylock (struct semaphore * sem);
 extern void __up (struct semaphore * sem);
 
 
 
 
 
 static inline void
 down (struct semaphore *sem)
 {
 
 
 
         if (((__builtin_constant_p(1) && ( (1 == 1) || (1 == 4) || (1 == 8) || (1 == 16) || (1 == -1) || (1 == -4) || (1 == -8) || (1 == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&((&sem->count))->counter)) *_v = (&((&sem->count))->counter); switch ( -(1)) { case -16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r" (_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory") ; break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&((&sem->count))->cou!
 nter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia 64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1] ,%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v) , "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&((!
 &sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: _ _bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchad d8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_ tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp =!
  __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&((&sem->count))->counter)) (_tmp + (-(1))); }) : ia64_atomic_sub(1, (&sem->count))) < 0)
                 __down(sem);
 }
 
 
 
 
 
 static inline int
 down_interruptible (struct semaphore * sem)
 {
         int ret = 0;
 
 
 
 
         if (((__builtin_constant_p(1) && ( (1 == 1) || (1 == 4) || (1 == 8) || (1 == 16) || (1 == -1) || (1 == -4) || (1 == -8) || (1 == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&((&sem->count))->counter)) *_v = (&((&sem->count))->counter); switch ( -(1)) { case -16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r" (_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory") ; break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&((&sem->count))->cou!
 nter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia 64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1] ,%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v) , "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&((!
 &sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: _ _bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchad d8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_ tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp =!
  __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&((&sem->count))->counter)) (_tmp + (-(1))); }) : ia64_atomic_sub(1, (&sem->count))) < 0)
                 ret = __down_interruptible(sem);
         return ret;
 }
 
 static inline int
 down_trylock (struct semaphore *sem)
 {
         int ret = 0;
 
 
 
 
         if (((__builtin_constant_p(1) && ( (1 == 1) || (1 == 4) || (1 == 8) || (1 == 16) || (1 == -1) || (1 == -4) || (1 == -8) || (1 == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&((&sem->count))->counter)) *_v = (&((&sem->count))->counter); switch ( -(1)) { case -16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r" (_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory") ; break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&((&sem->count))->cou!
 nter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia 64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1] ,%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v) , "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&((!
 &sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: _ _bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchad d8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_ tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp =!
  __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&((&sem->count))->counter)) (_tmp + (-(1))); }) : ia64_atomic_sub(1, (&sem->count))) < 0)
                 ret = __down_trylock(sem);
         return ret;
 }
 
 static inline void
 up (struct semaphore * sem)
 {
 
 
 
         if (((__builtin_constant_p(1) && ( (1 == 1) || (1 == 4) || (1 == 8) || (1 == 16) || (1 == -1) || (1 == -4) || (1 == -8) || (1 == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&((&sem->count))->counter)) *_v = (&((&sem->count))->counter); switch ( 1) { case -16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v ), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); b reak; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&((&sem->count))->counte!
 r))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia64_ fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2 " : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), " i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&((&se!
 m->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __ba d_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8. rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&((&sem->count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp ) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __!
 bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&((&sem->count))->counter)) (_tmp + (1)); }) : ia64_atomic_add(1, (&sem->count))) <= 0)
                 __up(sem);
 }
 # 203 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/asm/byteorder.h" 1
 # 11 "/data1/src/linux/include/asm/byteorder.h"
 static __inline__ __const__ __u64
 __ia64_swab64 (__u64 x)
 {
         __u64 result;
 
         __asm__ ("mux1 %0=%1,@rev" : "=r" (result) : "r" (x));
         return result;
 }
 
 static __inline__ __const__ __u32
 __ia64_swab32 (__u32 x)
 {
         return __ia64_swab64(x) >> 32;
 }
 
 static __inline__ __const__ __u16
 __ia64_swab16(__u16 x)
 {
         return __ia64_swab64(x) >> 48;
 }
 
 
 
 
 
 
 
 # 1 "/data1/src/linux/include/linux/byteorder/little_endian.h" 1
 # 11 "/data1/src/linux/include/linux/byteorder/little_endian.h"
 # 1 "/data1/src/linux/include/linux/byteorder/swab.h" 1
 # 131 "/data1/src/linux/include/linux/byteorder/swab.h"
 static __inline__ __const__ __u16 __fswab16(__u16 x)
 {
         return __ia64_swab16(x);
 }
 static __inline__ __u16 __swab16p(__u16 *x)
 {
         return __ia64_swab16(*(x));
 }
 static __inline__ void __swab16s(__u16 *addr)
 {
         do { *(addr) = __ia64_swab16(*((addr))); } while (0);
 }
 
 static __inline__ __const__ __u32 __fswab32(__u32 x)
 {
         return __ia64_swab32(x);
 }
 static __inline__ __u32 __swab32p(__u32 *x)
 {
         return __ia64_swab32(*(x));
 }
 static __inline__ void __swab32s(__u32 *addr)
 {
         do { *(addr) = __ia64_swab32(*((addr))); } while (0);
 }
 
 
 static __inline__ __const__ __u64 __fswab64(__u64 x)
 {
 
 
 
 
 
         return __ia64_swab64(x);
 
 }
 static __inline__ __u64 __swab64p(__u64 *x)
 {
         return __ia64_swab64(*(x));
 }
 static __inline__ void __swab64s(__u64 *addr)
 {
         do { *(addr) = __ia64_swab64(*((addr))); } while (0);
 }
 # 12 "/data1/src/linux/include/linux/byteorder/little_endian.h" 2
 # 66 "/data1/src/linux/include/linux/byteorder/little_endian.h"
 # 1 "/data1/src/linux/include/linux/byteorder/generic.h" 1
 # 150 "/data1/src/linux/include/linux/byteorder/generic.h"
 extern __u32 ntohl(__u32);
 extern __u32 htonl(__u32);
 
 
 
 
 extern unsigned short int ntohs(unsigned short int);
 extern unsigned short int htons(unsigned short int);
 # 67 "/data1/src/linux/include/linux/byteorder/little_endian.h" 2
 # 39 "/data1/src/linux/include/asm/byteorder.h" 2
 # 204 "/data1/src/linux/include/linux/fs.h" 2
 
 extern void update_atime (struct inode *);
 
 
 extern void buffer_init(unsigned long);
 extern void inode_init(unsigned long);
 extern void mnt_init(unsigned long);
 
 
 enum bh_state_bits {
         BH_Uptodate,
         BH_Dirty,
         BH_Lock,
         BH_Req,
         BH_Mapped,
         BH_New,
         BH_Async,
         BH_Wait_IO,
         BH_launder,
         BH_JBD,
 
         BH_PrivateStart,
 
 
 };
 # 241 "/data1/src/linux/include/linux/fs.h"
 struct buffer_head {
 
         struct buffer_head *b_next;
         sector_t b_blocknr;
         unsigned short b_size;
         unsigned short b_list;
         kdev_t b_dev;
         struct block_device *b_bdev;
 
         atomic_t b_count;
         unsigned long b_state;
         unsigned long b_flushtime;
 
         struct buffer_head *b_next_free;
         struct buffer_head *b_prev_free;
         struct buffer_head *b_this_page;
         struct buffer_head **b_pprev;
         char * b_data;
         struct page *b_page;
         void (*b_end_io)(struct buffer_head *bh, int uptodate);
         void *b_private;
 
         wait_queue_head_t b_wait;
 
         struct inode * b_inode;
         struct list_head b_inode_buffers;
 };
 
 typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
 void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
 # 284 "/data1/src/linux/include/linux/fs.h"
 extern void set_bh_page(struct buffer_head *bh, struct page *page, unsigned long offset);
 
 
 
 
 # 1 "/data1/src/linux/include/linux/pipe_fs_i.h" 1
 
 
 
 
 struct pipe_inode_info {
         wait_queue_head_t wait;
         char *base;
         unsigned int len;
         unsigned int start;
         unsigned int readers;
         unsigned int writers;
         unsigned int waiting_readers;
         unsigned int waiting_writers;
         unsigned int r_counter;
         unsigned int w_counter;
 };
 # 42 "/data1/src/linux/include/linux/pipe_fs_i.h"
 void pipe_wait(struct inode * inode);
 
 struct inode* pipe_new(struct inode* inode);
 # 290 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/minix_fs_i.h" 1
 
 
 
 
 
 
 struct minix_inode_info {
         union {
                 __u16 i1_data[16];
                 __u32 i2_data[16];
         } u;
 };
 # 291 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ext2_fs_i.h" 1
 # 22 "/data1/src/linux/include/linux/ext2_fs_i.h"
 struct ext2_inode_info {
         __u32 i_data[15];
         __u32 i_flags;
         __u32 i_faddr;
         __u8 i_frag_no;
         __u8 i_frag_size;
         __u16 i_osync;
         __u32 i_file_acl;
         __u32 i_dir_acl;
         __u32 i_dtime;
         __u32 i_block_group;
         __u32 i_next_alloc_block;
         __u32 i_next_alloc_goal;
         __u32 i_prealloc_block;
         __u32 i_prealloc_count;
         __u32 i_dir_start_lookup;
         int i_new_inode:1;
 };
 # 292 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ext3_fs_i.h" 1
 # 24 "/data1/src/linux/include/linux/ext3_fs_i.h"
 struct ext3_inode_info {
         __u32 i_data[15];
         __u32 i_flags;
 
 
 
 
 
 
         __u32 i_file_acl;
         __u32 i_dir_acl;
         __u32 i_dtime;
         __u32 i_block_group;
         __u32 i_state;
         __u32 i_next_alloc_block;
         __u32 i_next_alloc_goal;
 
 
 
 
         __u32 i_dir_start_lookup;
 
         struct list_head i_orphan;
 # 63 "/data1/src/linux/include/linux/ext3_fs_i.h"
         loff_t i_disksize;
 # 75 "/data1/src/linux/include/linux/ext3_fs_i.h"
         struct rw_semaphore truncate_sem;
 };
 # 293 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/hpfs_fs_i.h" 1
 
 
 
 struct hpfs_inode_info {
         unsigned long mmu_private;
         ino_t i_parent_dir;
         unsigned i_dno;
         unsigned i_dpos;
         unsigned i_dsubdno;
         unsigned i_file_sec;
         unsigned i_disk_sec;
         unsigned i_n_secs;
         unsigned i_ea_size;
         unsigned i_conv : 2;
         unsigned i_ea_mode : 1;
         unsigned i_ea_uid : 1;
         unsigned i_ea_gid : 1;
         unsigned i_dirty : 1;
         struct semaphore i_sem;
         loff_t **i_rddir_off;
 };
 # 294 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ntfs_fs_i.h" 1
 
 
 
 
 
 
 struct ntfs_attribute;
 struct ntfs_sb_info;
 
 
 
 
 typedef u8 ntfs_u8;
 typedef u16 ntfs_u16;
 typedef u32 ntfs_u32;
 typedef u64 ntfs_u64;
 typedef s8 ntfs_s8;
 typedef s16 ntfs_s16;
 typedef s32 ntfs_s32;
 typedef s64 ntfs_s64;
 
 
 
 
 typedef __kernel_mode_t ntmode_t;
 
 
 
 typedef uid_t ntfs_uid_t;
 
 
 
 typedef gid_t ntfs_gid_t;
 
 
 
 typedef __kernel_size_t ntfs_size_t;
 
 
 
 typedef __kernel_time_t ntfs_time_t;
 
 
 
 
 
 typedef u16 ntfs_wchar_t;
 
 
 
 
 typedef s64 ntfs_offset_t;
 
 
 
 
 typedef u64 ntfs_time64_t;
 # 69 "/data1/src/linux/include/linux/ntfs_fs_i.h"
 typedef s32 ntfs_cluster_t;
 
 
 
 struct ntfs_inode_info {
         struct ntfs_sb_info *vol;
         unsigned long i_number;
         __u16 sequence_number;
         unsigned char *attr;
         int attr_count;
         struct ntfs_attribute *attrs;
         int record_count;
         int *records;
 
         union {
                 struct {
                         int recordsize;
                         int clusters_per_record;
                 } index;
         } u;
 };
 # 295 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/msdos_fs_i.h" 1
 
 
 
 
 
 
 
 struct msdos_inode_info {
         unsigned long mmu_private;
         int i_start;
         int i_logstart;
         int i_attrs;
         int i_ctime_ms;
         int i_location;
         struct inode *i_fat_inode;
         struct list_head i_fat_hash;
 };
 # 296 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/umsdos_fs_i.h" 1
 # 39 "/data1/src/linux/include/linux/umsdos_fs_i.h"
 struct dir_locking_info {
         wait_queue_head_t p;
         short int looking;
         short int creating;
 
 
 
         long pid;
 
 };
 
 struct umsdos_inode_info {
         struct msdos_inode_info msdos_info;
         struct dir_locking_info dir_info;
         int i_patched;
         int i_is_hlink;
         off_t pos;
 };
 # 297 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/iso_fs_i.h" 1
 
 
 
 enum isofs_file_format {
         isofs_file_normal = 0,
         isofs_file_sparse = 1,
         isofs_file_compressed = 2,
 };
 
 
 
 
 struct iso_inode_info {
         unsigned int i_first_extent;
         unsigned char i_file_format;
         unsigned char i_format_parm[3];
         unsigned long i_next_section_ino;
         off_t i_section_size;
 };
 # 298 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/nfs_fs_i.h" 1
 
 
 
 
 
 # 1 "/data1/src/linux/include/linux/nfs.h" 1
 # 10 "/data1/src/linux/include/linux/nfs.h"
 # 1 "/data1/src/linux/include/linux/sunrpc/msg_prot.h" 1
 # 14 "/data1/src/linux/include/linux/sunrpc/msg_prot.h"
 enum rpc_auth_flavor {
         RPC_AUTH_NULL = 0,
         RPC_AUTH_UNIX = 1,
         RPC_AUTH_SHORT = 2,
         RPC_AUTH_DES = 3,
         RPC_AUTH_KRB = 4,
 };
 
 enum rpc_msg_type {
         RPC_CALL = 0,
         RPC_REPLY = 1
 };
 
 enum rpc_reply_stat {
         RPC_MSG_ACCEPTED = 0,
         RPC_MSG_DENIED = 1
 };
 
 enum rpc_accept_stat {
         RPC_SUCCESS = 0,
         RPC_PROG_UNAVAIL = 1,
         RPC_PROG_MISMATCH = 2,
         RPC_PROC_UNAVAIL = 3,
         RPC_GARBAGE_ARGS = 4,
         RPC_SYSTEM_ERR = 5
 };
 
 enum rpc_reject_stat {
         RPC_MISMATCH = 0,
         RPC_AUTH_ERROR = 1
 };
 
 enum rpc_auth_stat {
         RPC_AUTH_OK = 0,
         RPC_AUTH_BADCRED = 1,
         RPC_AUTH_REJECTEDCRED = 2,
         RPC_AUTH_BADVERF = 3,
         RPC_AUTH_REJECTEDVERF = 4,
         RPC_AUTH_TOOWEAK = 5
 };
 # 11 "/data1/src/linux/include/linux/nfs.h" 2
 # 41 "/data1/src/linux/include/linux/nfs.h"
  enum nfs_stat {
         NFS_OK = 0,
         NFSERR_PERM = 1,
         NFSERR_NOENT = 2,
         NFSERR_IO = 5,
         NFSERR_NXIO = 6,
         NFSERR_EAGAIN = 11,
         NFSERR_ACCES = 13,
         NFSERR_EXIST = 17,
         NFSERR_XDEV = 18,
         NFSERR_NODEV = 19,
         NFSERR_NOTDIR = 20,
         NFSERR_ISDIR = 21,
         NFSERR_INVAL = 22,
         NFSERR_FBIG = 27,
         NFSERR_NOSPC = 28,
         NFSERR_ROFS = 30,
         NFSERR_MLINK = 31,
         NFSERR_OPNOTSUPP = 45,
         NFSERR_NAMETOOLONG = 63,
         NFSERR_NOTEMPTY = 66,
         NFSERR_DQUOT = 69,
         NFSERR_STALE = 70,
         NFSERR_REMOTE = 71,
         NFSERR_WFLUSH = 99,
         NFSERR_BADHANDLE = 10001,
         NFSERR_NOT_SYNC = 10002,
         NFSERR_BAD_COOKIE = 10003,
         NFSERR_NOTSUPP = 10004,
         NFSERR_TOOSMALL = 10005,
         NFSERR_SERVERFAULT = 10006,
         NFSERR_BADTYPE = 10007,
         NFSERR_JUKEBOX = 10008
  };
 
 
 
 enum nfs_ftype {
         NFNON = 0,
         NFREG = 1,
         NFDIR = 2,
         NFBLK = 3,
         NFCHR = 4,
         NFLNK = 5,
         NFSOCK = 6,
         NFBAD = 7,
         NFFIFO = 8
 };
 
 
 
 
 
 
 struct nfs_fh {
         unsigned short size;
         unsigned char data[64];
 };
 # 107 "/data1/src/linux/include/linux/nfs.h"
 enum nfs3_stable_how {
         NFS_UNSTABLE = 0,
         NFS_DATA_SYNC = 1,
         NFS_FILE_SYNC = 2
 };
 # 7 "/data1/src/linux/include/linux/nfs_fs_i.h" 2
 
 
 
 
 struct nfs_inode_info {
 
 
 
         __u64 fsid;
         __u64 fileid;
 
 
 
 
         struct nfs_fh fh;
 
 
 
 
         unsigned short flags;
 # 45 "/data1/src/linux/include/linux/nfs_fs_i.h"
         unsigned long read_cache_jiffies;
         __u64 read_cache_ctime;
         __u64 read_cache_mtime;
         __u64 read_cache_isize;
         unsigned long attrtimeo;
         unsigned long attrtimeo_timestamp;
 
 
 
 
 
         __u32 cookieverf[2];
 
 
 
 
         struct list_head read;
         struct list_head dirty;
         struct list_head commit;
         struct list_head writeback;
 
         unsigned int nread,
                                 ndirty,
                                 ncommit,
                                 npages;
 
 
         struct inode *hash_next,
                                 *hash_prev;
         unsigned long nextscan;
 
 
         struct rpc_cred *mm_cred;
 };
 # 92 "/data1/src/linux/include/linux/nfs_fs_i.h"
 struct nfs_lock_info {
         u32 state;
         u32 flags;
         struct nlm_host *host;
 };
 # 299 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/sysv_fs_i.h" 1
 
 
 
 
 
 
 struct sysv_inode_info {
         u32 i_data[10+1+1+1];
 
 
 
 
         u32 i_dir_start_lookup;
 };
 # 300 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/affs_fs_i.h" 1
 
 
 
 # 1 "/data1/src/linux/include/linux/a.out.h" 1
 
 
 
 
 
 
 
 # 1 "/data1/src/linux/include/asm/a.out.h" 1
 # 16 "/data1/src/linux/include/asm/a.out.h"
 struct exec {
         unsigned long a_info;
         unsigned long a_text;
         unsigned long a_data;
         unsigned long a_bss;
         unsigned long a_entry;
 };
 # 9 "/data1/src/linux/include/linux/a.out.h" 2
 
 
 
 
 enum machine_type {
 
 
 
   M_OLDSUN2 = 0,
 
 
 
 
   M_68010 = 1,
 
 
 
 
   M_68020 = 2,
 
 
 
 
   M_SPARC = 3,
 
 
   M_386 = 100,
   M_MIPS1 = 151,
   M_MIPS2 = 152
 };
 # 157 "/data1/src/linux/include/linux/a.out.h"
 struct nlist {
   union {
     char *n_name;
     struct nlist *n_next;
     long n_strx;
   } n_un;
   unsigned char n_type;
   char n_other;
   short n_desc;
   unsigned long n_value;
 };
 # 235 "/data1/src/linux/include/linux/a.out.h"
 struct relocation_info
 {
 
   int r_address;
 
   unsigned int r_symbolnum:24;
 
 
 
   unsigned int r_pcrel:1;
 
 
   unsigned int r_length:2;
 
 
 
 
 
 
   unsigned int r_extern:1;
 
 
 
 
 
 
 
   unsigned int r_pad:4;
 
 };
 # 5 "/data1/src/linux/include/linux/affs_fs_i.h" 2
 
 
 # 1 "/data1/src/linux/include/linux/time.h" 1
 # 9 "/data1/src/linux/include/linux/time.h"
 struct timespec {
         time_t tv_sec;
         long tv_nsec;
 };
 # 31 "/data1/src/linux/include/linux/time.h"
 static __inline__ unsigned long
 timespec_to_jiffies(struct timespec *value)
 {
         unsigned long sec = value->tv_sec;
         long nsec = value->tv_nsec;
 
         if (sec >= (((~0UL >> 1)-1) / 1024))
                 return ((~0UL >> 1)-1);
         nsec += 1000000000L / 1024 - 1;
         nsec /= 1000000000L / 1024;
         return 1024 * sec + nsec;
 }
 
 static __inline__ void
 jiffies_to_timespec(unsigned long jiffies, struct timespec *value)
 {
         value->tv_nsec = (jiffies % 1024) * (1000000000L / 1024);
         value->tv_sec = jiffies / 1024;
 }
 # 67 "/data1/src/linux/include/linux/time.h"
 static inline unsigned long
 mktime (unsigned int year, unsigned int mon,
         unsigned int day, unsigned int hour,
         unsigned int min, unsigned int sec)
 {
         if (0 >= (int) (mon -= 2)) {
                 mon += 12;
                 year -= 1;
         }
 
         return (((
                 (unsigned long) (year/4 - year/100 + year/400 + 367*mon/12 + day) +
                         year*365 - 719499
             )*24 + hour
           )*60 + min
         )*60 + sec;
 }
 
 
 
 
 struct timeval {
         time_t tv_sec;
         suseconds_t tv_usec;
 };
 
 struct timezone {
         int tz_minuteswest;
         int tz_dsttime;
 };
 
 
 
 
 extern void do_gettimeofday(struct timeval *tv);
 extern void do_settimeofday(struct timeval *tv);
 extern void get_fast_time(struct timeval *tv);
 # 124 "/data1/src/linux/include/linux/time.h"
 struct itimerspec {
         struct timespec it_interval;
         struct timespec it_value;
 };
 
 struct itimerval {
         struct timeval it_interval;
         struct timeval it_value;
 };
 # 8 "/data1/src/linux/include/linux/affs_fs_i.h" 2
 # 17 "/data1/src/linux/include/linux/affs_fs_i.h"
 struct affs_ext_key {
         u32 ext;
         u32 key;
 };
 
 
 
 
 struct affs_inode_info {
         u32 i_opencnt;
         struct semaphore i_link_lock;
         struct semaphore i_ext_lock;
 
         u32 i_blkcnt;
         u32 i_extcnt;
         u32 *i_lc;
         u32 i_lc_size;
         u32 i_lc_shift;
         u32 i_lc_mask;
         struct affs_ext_key *i_ac;
         u32 i_ext_last;
         struct buffer_head *i_ext_bh;
         unsigned long mmu_private;
         u32 i_protect;
         u32 i_lastalloc;
         int i_pa_cnt;
 # 51 "/data1/src/linux/include/linux/affs_fs_i.h"
 };
 # 301 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ufs_fs_i.h" 1
 # 16 "/data1/src/linux/include/linux/ufs_fs_i.h"
 struct ufs_inode_info {
         union {
                 __u32 i_data[15];
                 __u8 i_symlink[4*15];
         } i_u1;
         __u32 i_flags;
         __u32 i_gen;
         __u32 i_shadow;
         __u32 i_unused1;
         __u32 i_unused2;
         __u32 i_oeftflag;
         __u16 i_osync;
         __u32 i_lastfrag;
 };
 # 302 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/efs_fs_i.h" 1
 # 12 "/data1/src/linux/include/linux/efs_fs_i.h"
 typedef int32_t efs_block_t;
 typedef uint32_t efs_ino_t;
 
 
 
 
 
 
 typedef union extent_u {
         unsigned char raw[8];
         struct extent_s {
                 unsigned int ex_magic:8;
                 unsigned int ex_bn:24;
                 unsigned int ex_length:8;
                 unsigned int ex_offset:24;
         } cooked;
 } efs_extent;
 
 typedef struct edevs {
         short odev;
         unsigned int ndev;
 } efs_devs;
 
 
 
 
 
 struct efs_dinode {
         u_short di_mode;
         short di_nlink;
         u_short di_uid;
         u_short di_gid;
         int32_t di_size;
         int32_t di_atime;
         int32_t di_mtime;
         int32_t di_ctime;
         uint32_t di_gen;
         short di_numextents;
         u_char di_version;
         u_char di_spare;
         union di_addr {
                 efs_extent di_extents[12];
                 efs_devs di_dev;
         } di_u;
 };
 
 
 struct efs_inode_info {
         int numextents;
         int lastextent;
 
         efs_extent extents[12];
 };
 # 303 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/coda_fs_i.h" 1
 # 14 "/data1/src/linux/include/linux/coda_fs_i.h"
 # 1 "/data1/src/linux/include/linux/coda.h" 1
 # 109 "/data1/src/linux/include/linux/coda.h"
 typedef unsigned long long u_quad_t;
 # 164 "/data1/src/linux/include/linux/coda.h"
 struct venus_dirent {
         unsigned long d_fileno;
         unsigned short d_reclen;
         unsigned char d_type;
         unsigned char d_namlen;
         char d_name[255 + 1];
 };
 # 198 "/data1/src/linux/include/linux/coda.h"
 typedef u_long VolumeId;
 typedef u_long VnodeId;
 typedef u_long Unique_t;
 typedef u_long FileVersion;
 
 
 
 
 typedef struct ViceFid {
     VolumeId Volume;
     VnodeId Vnode;
     Unique_t Unique;
 } ViceFid;
 
 
 
 
 static __inline__ ino_t coda_f2i(struct ViceFid *fid)
 {
         if ( ! fid )
                 return 0;
         if (fid->Vnode == 0xfffffffe || fid->Vnode == 0xffffffff)
                 return ((fid->Volume << 20) | (fid->Unique & 0xfffff));
         else
                 return (fid->Unique + (fid->Vnode<<10) + (fid->Volume<<20));
 }
 # 233 "/data1/src/linux/include/linux/coda.h"
 typedef u_int32_t vuid_t;
 typedef u_int32_t vgid_t;
 
 
 
 
 struct coda_cred {
     vuid_t cr_uid, cr_euid, cr_suid, cr_fsuid;
     vgid_t cr_groupid, cr_egid, cr_sgid, cr_fsgid;
 };
 
 
 
 
 
 
 
 enum coda_vtype { C_VNON, C_VREG, C_VDIR, C_VBLK, C_VCHR, C_VLNK, C_VSOCK, C_VFIFO, C_VBAD };
 
 struct coda_vattr {
         long va_type;
         u_short va_mode;
         short va_nlink;
         vuid_t va_uid;
         vgid_t va_gid;
         long va_fileid;
         u_quad_t va_size;
         long va_blocksize;
         struct timespec va_atime;
         struct timespec va_mtime;
         struct timespec va_ctime;
         u_long va_gen;
         u_long va_flags;
         u_quad_t va_rdev;
         u_quad_t va_bytes;
         u_quad_t va_filerev;
 };
 
 
 
 
 struct coda_statfs {
     int32_t f_blocks;
     int32_t f_bfree;
     int32_t f_bavail;
     int32_t f_files;
     int32_t f_ffree;
 };
 # 337 "/data1/src/linux/include/linux/coda.h"
 struct coda_in_hdr {
     unsigned long opcode;
     unsigned long unique;
     u_short pid;
     u_short pgid;
     u_short sid;
     struct coda_cred cred;
 };
 
 
 struct coda_out_hdr {
     unsigned long opcode;
     unsigned long unique;
     unsigned long result;
 };
 
 
 struct coda_root_out {
     struct coda_out_hdr oh;
     ViceFid VFid;
 };
 
 struct coda_root_in {
     struct coda_in_hdr in;
 };
 
 
 struct coda_open_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_open_out {
     struct coda_out_hdr oh;
     u_quad_t dev;
     ino_t inode;
 };
 
 
 
 struct coda_store_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_store_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_release_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_release_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_close_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_close_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_ioctl_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int cmd;
     int len;
     int rwflag;
     char *data;
 };
 
 struct coda_ioctl_out {
     struct coda_out_hdr oh;
     int len;
     caddr_t data;
 };
 
 
 
 struct coda_getattr_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
 };
 
 struct coda_getattr_out {
     struct coda_out_hdr oh;
     struct coda_vattr attr;
 };
 
 
 
 struct coda_setattr_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     struct coda_vattr attr;
 };
 
 struct coda_setattr_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_access_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_access_out {
     struct coda_out_hdr out;
 };
 
 
 
 
 
 
 
 struct coda_lookup_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int name;
     int flags;
 };
 
 struct coda_lookup_out {
     struct coda_out_hdr oh;
     ViceFid VFid;
     int vtype;
 };
 
 
 
 struct coda_create_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     struct coda_vattr attr;
     int excl;
     int mode;
     int name;
 };
 
 struct coda_create_out {
     struct coda_out_hdr oh;
     ViceFid VFid;
     struct coda_vattr attr;
 };
 
 
 
 struct coda_remove_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int name;
 };
 
 struct coda_remove_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_link_in {
     struct coda_in_hdr ih;
     ViceFid sourceFid;
     ViceFid destFid;
     int tname;
 };
 
 struct coda_link_out {
     struct coda_out_hdr out;
 };
 
 
 
 struct coda_rename_in {
     struct coda_in_hdr ih;
     ViceFid sourceFid;
     int srcname;
     ViceFid destFid;
     int destname;
 };
 
 struct coda_rename_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_mkdir_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     struct coda_vattr attr;
     int name;
 };
 
 struct coda_mkdir_out {
     struct coda_out_hdr oh;
     ViceFid VFid;
     struct coda_vattr attr;
 };
 
 
 
 struct coda_rmdir_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int name;
 };
 
 struct coda_rmdir_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_symlink_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int srcname;
     struct coda_vattr attr;
     int tname;
 };
 
 struct coda_symlink_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_readlink_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
 };
 
 struct coda_readlink_out {
     struct coda_out_hdr oh;
     int count;
     caddr_t data;
 };
 
 
 
 struct coda_fsync_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
 };
 
 struct coda_fsync_out {
     struct coda_out_hdr out;
 };
 
 
 struct coda_vget_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
 };
 
 struct coda_vget_out {
     struct coda_out_hdr oh;
     ViceFid VFid;
     int vtype;
 };
 # 616 "/data1/src/linux/include/linux/coda.h"
 struct coda_purgeuser_out {
     struct coda_out_hdr oh;
     struct coda_cred cred;
 };
 
 
 
 struct coda_zapfile_out {
     struct coda_out_hdr oh;
     ViceFid CodaFid;
 };
 
 
 
 struct coda_zapdir_out {
     struct coda_out_hdr oh;
     ViceFid CodaFid;
 };
 
 
 
 struct coda_zapvnode_out {
     struct coda_out_hdr oh;
     struct coda_cred cred;
     ViceFid VFid;
 };
 
 
 
 struct coda_purgefid_out {
     struct coda_out_hdr oh;
     ViceFid CodaFid;
 };
 
 
 
 struct coda_replace_out {
     struct coda_out_hdr oh;
     ViceFid NewFid;
     ViceFid OldFid;
 };
 
 
 struct coda_open_by_fd_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_open_by_fd_out {
     struct coda_out_hdr oh;
     int fd;
 
 
     struct file *fh;
 
 };
 
 
 struct coda_open_by_path_in {
     struct coda_in_hdr ih;
     ViceFid VFid;
     int flags;
 };
 
 struct coda_open_by_path_out {
     struct coda_out_hdr oh;
         int path;
 };
 
 
 struct coda_statfs_in {
     struct coda_in_hdr in;
 };
 
 struct coda_statfs_out {
     struct coda_out_hdr oh;
     struct coda_statfs stat;
 };
 # 703 "/data1/src/linux/include/linux/coda.h"
 union inputArgs {
     struct coda_in_hdr ih;
     struct coda_open_in coda_open;
     struct coda_store_in coda_store;
     struct coda_release_in coda_release;
     struct coda_close_in coda_close;
     struct coda_ioctl_in coda_ioctl;
     struct coda_getattr_in coda_getattr;
     struct coda_setattr_in coda_setattr;
     struct coda_access_in coda_access;
     struct coda_lookup_in coda_lookup;
     struct coda_create_in coda_create;
     struct coda_remove_in coda_remove;
     struct coda_link_in coda_link;
     struct coda_rename_in coda_rename;
     struct coda_mkdir_in coda_mkdir;
     struct coda_rmdir_in coda_rmdir;
     struct coda_symlink_in coda_symlink;
     struct coda_readlink_in coda_readlink;
     struct coda_fsync_in coda_fsync;
     struct coda_vget_in coda_vget;
     struct coda_open_by_fd_in coda_open_by_fd;
     struct coda_open_by_path_in coda_open_by_path;
     struct coda_statfs_in coda_statfs;
 };
 
 union outputArgs {
     struct coda_out_hdr oh;
     struct coda_root_out coda_root;
     struct coda_open_out coda_open;
     struct coda_ioctl_out coda_ioctl;
     struct coda_getattr_out coda_getattr;
     struct coda_lookup_out coda_lookup;
     struct coda_create_out coda_create;
     struct coda_mkdir_out coda_mkdir;
     struct coda_readlink_out coda_readlink;
     struct coda_vget_out coda_vget;
     struct coda_purgeuser_out coda_purgeuser;
     struct coda_zapfile_out coda_zapfile;
     struct coda_zapdir_out coda_zapdir;
     struct coda_zapvnode_out coda_zapvnode;
     struct coda_purgefid_out coda_purgefid;
     struct coda_replace_out coda_replace;
     struct coda_open_by_fd_out coda_open_by_fd;
     struct coda_open_by_path_out coda_open_by_path;
     struct coda_statfs_out coda_statfs;
 };
 
 union coda_downcalls {
 
 
     struct coda_purgeuser_out purgeuser;
     struct coda_zapfile_out zapfile;
     struct coda_zapdir_out zapdir;
     struct coda_zapvnode_out zapvnode;
     struct coda_purgefid_out purgefid;
     struct coda_replace_out replace;
 };
 
 
 
 
 
 
 
 struct ViceIoctl {
         caddr_t in, out;
         short in_size;
         short out_size;
 };
 
 struct PioctlData {
         const char *path;
         int follow;
         struct ViceIoctl vi;
 };
 # 797 "/data1/src/linux/include/linux/coda.h"
 struct coda_mount_data {
         int version;
         int fd;
 };
 # 15 "/data1/src/linux/include/linux/coda_fs_i.h" 2
 
 
 
 
 struct coda_inode_info {
         struct ViceFid c_fid;
         u_short c_flags;
         struct list_head c_cilist;
         struct file *c_container;
         unsigned int c_contcount;
         struct coda_cred c_cached_cred;
         unsigned int c_cached_perm;
 };
 
 
 
 
 
 
 
 int coda_cnode_make(struct inode **, struct ViceFid *, struct super_block *);
 int coda_cnode_makectl(struct inode **inode, struct super_block *sb);
 struct inode *coda_fid_to_inode(ViceFid *fid, struct super_block *sb);
 void coda_replace_fid(struct inode *, ViceFid *, ViceFid *);
 # 304 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/romfs_fs_i.h" 1
 
 
 
 
 
 struct romfs_inode_info {
         unsigned long i_metasize;
         unsigned long i_dataoffset;
 };
 # 305 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/shmem_fs.h" 1
 # 16 "/data1/src/linux/include/linux/shmem_fs.h"
 typedef struct {
         unsigned long val;
 } swp_entry_t;
 
 extern atomic_t shmem_nrpages;
 
 struct shmem_inode_info {
         spinlock_t lock;
         struct semaphore sem;
         unsigned long next_index;
         swp_entry_t i_direct[16];
         void **i_indirect;
         unsigned long swapped;
         int locked;
         struct list_head list;
         struct inode *inode;
 };
 
 struct shmem_sb_info {
         unsigned long max_blocks;
         unsigned long free_blocks;
         unsigned long max_inodes;
         unsigned long free_inodes;
         spinlock_t stat_lock;
 };
 # 306 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/smb_fs_i.h" 1
 # 18 "/data1/src/linux/include/linux/smb_fs_i.h"
 struct smb_inode_info {
 
 
 
 
 
         unsigned int open;
         __u16 fileid;
         __u16 attr;
 
         __u16 access;
         __u16 flags;
         unsigned long oldmtime;
         unsigned long closed;
         unsigned openers;
 };
 # 307 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/hfs_fs_i.h" 1
 # 19 "/data1/src/linux/include/linux/hfs_fs_i.h"
 struct hfs_inode_info {
         int magic;
 
         unsigned long mmu_private;
         struct hfs_cat_entry *entry;
 
 
         struct hfs_fork *fork;
         int convert;
 
 
         ino_t file_type;
         char dir_size;
 
 
         const struct hfs_hdr_layout *default_layout;
         struct hfs_hdr_layout *layout;
 
 
         int tz_secondswest;
 
 
         void (*d_drop_op)(struct dentry *, const ino_t);
 };
 # 308 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/adfs_fs_i.h" 1
 # 13 "/data1/src/linux/include/linux/adfs_fs_i.h"
 struct adfs_inode_info {
         unsigned long mmu_private;
         unsigned long parent_id;
         __u32 loadaddr;
         __u32 execaddr;
         unsigned int filetype;
         unsigned int attr;
         int stamped:1;
 };
 # 309 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/qnx4_fs_i.h" 1
 # 14 "/data1/src/linux/include/linux/qnx4_fs_i.h"
 # 1 "/data1/src/linux/include/linux/qnxtypes.h" 1
 # 15 "/data1/src/linux/include/linux/qnxtypes.h"
 typedef __u16 qnx4_nxtnt_t;
 typedef __u8 qnx4_ftype_t;
 
 typedef struct {
         __u32 xtnt_blk;
         __u32 xtnt_size;
 } qnx4_xtnt_t;
 
 typedef __u16 qnx4_mode_t;
 typedef __u16 qnx4_muid_t;
 typedef __u16 qnx4_mgid_t;
 typedef __u32 qnx4_off_t;
 typedef __u16 qnx4_nlink_t;
 # 15 "/data1/src/linux/include/linux/qnx4_fs_i.h" 2
 
 
 
 
 struct qnx4_inode_info {
         char i_reserved[16];
         qnx4_off_t i_size;
         qnx4_xtnt_t i_first_xtnt;
         __u32 i_xblk;
         __s32 i_ftime;
         __s32 i_mtime;
         __s32 i_atime;
         __s32 i_ctime;
         qnx4_nxtnt_t i_num_xtnts;
         qnx4_mode_t i_mode;
         qnx4_muid_t i_uid;
         qnx4_mgid_t i_gid;
         qnx4_nlink_t i_nlink;
         __u8 i_zero[4];
         qnx4_ftype_t i_type;
         __u8 i_status;
         unsigned long mmu_private;
 };
 # 310 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/reiserfs_fs_i.h" 1
 
 
 
 
 
 struct reiserfs_inode_info {
   __u32 i_key [4];
 
 
 
 
 
 
   int i_version;
 
   int i_pack_on_close ;
 
   __u32 i_first_direct_byte;
 # 35 "/data1/src/linux/include/linux/reiserfs_fs_i.h"
   int i_prealloc_block;
   int i_prealloc_count;
   struct list_head i_prealloc_list;
 
 
 
 
   int nopack;
 
 
 
 
   unsigned long i_trans_id ;
   unsigned long i_trans_index ;
 };
 # 311 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/bfs_fs_i.h" 1
 # 12 "/data1/src/linux/include/linux/bfs_fs_i.h"
 struct bfs_inode_info {
         unsigned long i_dsk_ino;
         unsigned long i_sblock;
         unsigned long i_eblock;
 };
 # 312 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/udf_fs_i.h" 1
 # 24 "/data1/src/linux/include/linux/udf_fs_i.h"
 typedef struct
 {
         __u32 logicalBlockNum;
         __u16 partitionReferenceNum;
 } lb_addr;
 
 
 struct udf_inode_info
 {
         long i_umtime;
         long i_uctime;
         long i_crtime;
         long i_ucrtime;
 
         lb_addr i_location;
         __u64 i_unique;
         __u32 i_lenEAttr;
         __u32 i_lenAlloc;
         __u64 i_lenExtents;
         __u32 i_next_alloc_block;
         __u32 i_next_alloc_goal;
         unsigned i_alloc_type : 3;
         unsigned i_extended_fe : 1;
         unsigned i_strat_4096 : 1;
         unsigned i_new_inode : 1;
         unsigned reserved : 26;
 };
 # 313 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ncp_fs_i.h" 1
 # 17 "/data1/src/linux/include/linux/ncp_fs_i.h"
 struct ncp_inode_info {
         __u32 dirEntNum __attribute__((packed));
         __u32 DosDirNum __attribute__((packed));
         __u32 volNumber __attribute__((packed));
         __u32 nwattr;
         struct semaphore open_sem;
         atomic_t opened;
         int access;
         __u32 server_file_handle __attribute__((packed));
         __u8 open_create_action __attribute__((packed));
         __u8 file_handle[6] __attribute__((packed));
 };
 # 314 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/proc_fs_i.h" 1
 struct proc_inode_info {
         struct task_struct *task;
         int type;
         union {
                 int (*proc_get_link)(struct inode *, struct dentry **, struct vfsmount **);
                 int (*proc_read)(struct task_struct *task, char *page);
         } op;
         struct file *file;
 };
 # 315 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/jffs2_fs_i.h" 1
 # 16 "/data1/src/linux/include/linux/jffs2_fs_i.h"
 struct jffs2_inode_info {
 # 26 "/data1/src/linux/include/linux/jffs2_fs_i.h"
         struct semaphore sem;
 
 
         __u32 highest_version;
 
 
         struct jffs2_node_frag *fraglist;
 
 
 
 
 
 
         struct jffs2_full_dnode *metadata;
 
 
         struct jffs2_full_dirent *dents;
 
 
         struct jffs2_inode_cache *inocache;
 
 
 
 
 
         __u16 flags;
         __u8 usercompr;
 };
 # 316 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/cramfs_fs_sb.h" 1
 
 
 
 
 
 
 struct cramfs_sb_info {
                         unsigned long magic;
                         unsigned long size;
                         unsigned long blocks;
                         unsigned long files;
                         unsigned long flags;
 };
 # 317 "/data1/src/linux/include/linux/fs.h" 2
 # 343 "/data1/src/linux/include/linux/fs.h"
 struct iattr {
         unsigned int ia_valid;
         umode_t ia_mode;
         uid_t ia_uid;
         gid_t ia_gid;
         loff_t ia_size;
         time_t ia_atime;
         time_t ia_mtime;
         time_t ia_ctime;
         unsigned int ia_attr_flags;
 };
 # 367 "/data1/src/linux/include/linux/fs.h"
 # 1 "/data1/src/linux/include/linux/quota.h" 1
 # 42 "/data1/src/linux/include/linux/quota.h"
 # 1 "/data1/src/linux/include/linux/errno.h" 1
 
 
 
 # 1 "/data1/src/linux/include/asm/errno.h" 1
 # 5 "/data1/src/linux/include/linux/errno.h" 2
 # 43 "/data1/src/linux/include/linux/quota.h" 2
 # 109 "/data1/src/linux/include/linux/quota.h"
 struct dqblk {
         __u32 dqb_bhardlimit;
         __u32 dqb_bsoftlimit;
         __u32 dqb_curblocks;
         __u32 dqb_ihardlimit;
         __u32 dqb_isoftlimit;
         __u32 dqb_curinodes;
         time_t dqb_btime;
         time_t dqb_itime;
 };
 # 134 "/data1/src/linux/include/linux/quota.h"
 struct dqstats {
         __u32 lookups;
         __u32 drops;
         __u32 reads;
         __u32 writes;
         __u32 cache_hits;
         __u32 allocated_dquots;
         __u32 free_dquots;
         __u32 syncs;
 };
 
 
 
 extern int nr_dquots, nr_free_dquots;
 extern int dquot_root_squash;
 # 159 "/data1/src/linux/include/linux/quota.h"
 struct dquot {
         struct list_head dq_hash;
         struct list_head dq_inuse;
         struct list_head dq_free;
         wait_queue_head_t dq_wait_lock;
         wait_queue_head_t dq_wait_free;
         int dq_count;
 
 
         struct super_block *dq_sb;
         unsigned int dq_id;
         short dq_type;
         short dq_flags;
         unsigned long dq_referenced;
 
         struct dqblk dq_dqb;
 };
 # 368 "/data1/src/linux/include/linux/fs.h" 2
 
 
 
 
 
 struct page;
 struct address_space;
 struct kiobuf;
 
 struct address_space_operations {
         int (*writepage)(struct page *);
         int (*readpage)(struct file *, struct page *);
         int (*sync_page)(struct page *);
 
 
 
 
         int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
         int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
 
         int (*bmap)(struct address_space *, long);
         int (*flushpage) (struct page *, unsigned long);
         int (*releasepage) (struct page *, int);
 
         int (*direct_IO)(int, struct inode *, struct kiobuf *, unsigned long, int);
 };
 
 struct address_space {
         struct list_head clean_pages;
         struct list_head dirty_pages;
         struct list_head locked_pages;
         unsigned long nrpages;
         struct address_space_operations *a_ops;
         struct inode *host;
         struct vm_area_struct *i_mmap;
         struct vm_area_struct *i_mmap_shared;
         spinlock_t i_shared_lock;
         int gfp_mask;
 };
 
 struct char_device {
         struct list_head hash;
         atomic_t count;
         dev_t dev;
         atomic_t openers;
         struct semaphore sem;
 };
 
 struct block_device {
         struct list_head bd_hash;
         atomic_t bd_count;
         struct inode * bd_inode;
         dev_t bd_dev;
         int bd_openers;
         const struct block_device_operations *bd_op;
         struct semaphore bd_sem;
         struct list_head bd_inodes;
 };
 
 struct inode {
         struct list_head i_hash;
         struct list_head i_list;
         struct list_head i_dentry;
 
         struct list_head i_dirty_buffers;
         struct list_head i_dirty_data_buffers;
 
         unsigned long i_ino;
         atomic_t i_count;
         kdev_t i_dev;
         umode_t i_mode;
         nlink_t i_nlink;
         uid_t i_uid;
         gid_t i_gid;
         kdev_t i_rdev;
         loff_t i_size;
         time_t i_atime;
         time_t i_mtime;
         time_t i_ctime;
         unsigned int i_blkbits;
         unsigned long i_blksize;
         unsigned long i_blocks;
         unsigned long i_version;
         struct semaphore i_sem;
         struct semaphore i_zombie;
         struct inode_operations *i_op;
         struct file_operations *i_fop;
         struct super_block *i_sb;
         wait_queue_head_t i_wait;
         struct file_lock *i_flock;
         struct address_space *i_mapping;
         struct address_space i_data;
         struct dquot *i_dquot[2];
 
         struct list_head i_devices;
         struct pipe_inode_info *i_pipe;
         struct block_device *i_bdev;
         struct char_device *i_cdev;
 
         unsigned long i_dnotify_mask;
         struct dnotify_struct *i_dnotify;
 
         unsigned long i_state;
 
         unsigned int i_flags;
         unsigned char i_sock;
 
         atomic_t i_writecount;
         unsigned int i_attr_flags;
         __u32 i_generation;
         union {
                 struct minix_inode_info minix_i;
                 struct ext2_inode_info ext2_i;
                 struct ext3_inode_info ext3_i;
                 struct hpfs_inode_info hpfs_i;
                 struct ntfs_inode_info ntfs_i;
                 struct msdos_inode_info msdos_i;
                 struct umsdos_inode_info umsdos_i;
                 struct iso_inode_info isofs_i;
                 struct nfs_inode_info nfs_i;
                 struct sysv_inode_info sysv_i;
                 struct affs_inode_info affs_i;
                 struct ufs_inode_info ufs_i;
                 struct efs_inode_info efs_i;
                 struct romfs_inode_info romfs_i;
                 struct shmem_inode_info shmem_i;
                 struct coda_inode_info coda_i;
                 struct smb_inode_info smbfs_i;
                 struct hfs_inode_info hfs_i;
                 struct adfs_inode_info adfs_i;
                 struct qnx4_inode_info qnx4_i;
                 struct reiserfs_inode_info reiserfs_i;
                 struct bfs_inode_info bfs_i;
                 struct udf_inode_info udf_i;
                 struct ncp_inode_info ncpfs_i;
                 struct proc_inode_info proc_i;
                 struct socket socket_i;
                 struct jffs2_inode_info jffs2_i;
                 void *generic_ip;
         } u;
 };
 
 struct fown_struct {
         int pid;
         uid_t uid, euid;
         int signum;
 };
 
 struct file {
         struct list_head f_list;
         struct dentry *f_dentry;
         struct vfsmount *f_vfsmnt;
         struct file_operations *f_op;
         atomic_t f_count;
         unsigned int f_flags;
         mode_t f_mode;
         loff_t f_pos;
         unsigned long f_reada, f_ramax, f_raend, f_ralen, f_rawin;
         struct fown_struct f_owner;
         unsigned int f_uid, f_gid;
         int f_error;
 
         unsigned long f_version;
 
 
         void *private_data;
 
 
         struct kiobuf *f_iobuf;
         long f_iobuf_lock;
 };
 extern spinlock_t files_lock;
 
 
 
 
 
 
 extern int init_private_file(struct file *, struct dentry *, int);
 # 564 "/data1/src/linux/include/linux/fs.h"
 typedef struct files_struct *fl_owner_t;
 
 struct file_lock {
         struct file_lock *fl_next;
         struct list_head fl_link;
         struct list_head fl_block;
         fl_owner_t fl_owner;
         unsigned int fl_pid;
         wait_queue_head_t fl_wait;
         struct file *fl_file;
         unsigned char fl_flags;
         unsigned char fl_type;
         loff_t fl_start;
         loff_t fl_end;
 
         void (*fl_notify)(struct file_lock *);
         void (*fl_insert)(struct file_lock *);
         void (*fl_remove)(struct file_lock *);
 
         struct fasync_struct * fl_fasync;
 
         union {
                 struct nfs_lock_info nfs_fl;
         } fl_u;
 };
 # 597 "/data1/src/linux/include/linux/fs.h"
 extern struct list_head file_lock_list;
 
 # 1 "/data1/src/linux/include/linux/fcntl.h" 1
 
 
 
 # 1 "/data1/src/linux/include/asm/fcntl.h" 1
 # 73 "/data1/src/linux/include/asm/fcntl.h"
 struct flock {
         short l_type;
         short l_whence;
         off_t l_start;
         off_t l_len;
         pid_t l_pid;
 };
 # 5 "/data1/src/linux/include/linux/fcntl.h" 2
 # 600 "/data1/src/linux/include/linux/fs.h" 2
 
 extern int fcntl_getlk(unsigned int, struct flock *);
 extern int fcntl_setlk(unsigned int, unsigned int, struct flock *);
 
 extern int fcntl_getlk64(unsigned int, struct flock *);
 extern int fcntl_setlk64(unsigned int, unsigned int, struct flock *);
 
 
 extern void locks_init_lock(struct file_lock *);
 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
 extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, unsigned int);
 extern void posix_block_lock(struct file_lock *, struct file_lock *);
 extern void posix_unblock_lock(struct file_lock *);
 extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
 extern int __get_lease(struct inode *inode, unsigned int flags);
 extern time_t lease_get_mtime(struct inode *);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
 
 struct fasync_struct {
         int magic;
         int fa_fd;
         struct fasync_struct *fa_next;
         struct file *fa_file;
 };
 
 
 
 
 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
 
 extern void kill_fasync(struct fasync_struct **, int, int);
 
 extern void __kill_fasync(struct fasync_struct *, int, int);
 
 struct nameidata {
         struct dentry *dentry;
         struct vfsmount *mnt;
         struct qstr last;
         unsigned int flags;
         int last_type;
 };
 
 
 
 
 struct quota_mount_options
 {
         unsigned int flags;
         struct semaphore dqio_sem;
         struct semaphore dqoff_sem;
         struct file *files[2];
         time_t inode_expire[2];
         time_t block_expire[2];
         char rsquash[2];
 };
 # 667 "/data1/src/linux/include/linux/fs.h"
 # 1 "/data1/src/linux/include/linux/minix_fs_sb.h" 1
 
 
 
 
 
 
 struct minix_sb_info {
                         unsigned long s_ninodes;
                         unsigned long s_nzones;
                         unsigned long s_imap_blocks;
                         unsigned long s_zmap_blocks;
                         unsigned long s_firstdatazone;
                         unsigned long s_log_zone_size;
                         unsigned long s_max_size;
                         int s_dirsize;
                         int s_namelen;
                         int s_link_max;
                         struct buffer_head ** s_imap;
                         struct buffer_head ** s_zmap;
                         struct buffer_head * s_sbh;
                         struct minix_super_block * s_ms;
                         unsigned short s_mount_state;
                         unsigned short s_version;
 };
 # 668 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ext2_fs_sb.h" 1
 # 30 "/data1/src/linux/include/linux/ext2_fs_sb.h"
 struct ext2_sb_info {
         unsigned long s_frag_size;
         unsigned long s_frags_per_block;
         unsigned long s_inodes_per_block;
         unsigned long s_frags_per_group;
         unsigned long s_blocks_per_group;
         unsigned long s_inodes_per_group;
         unsigned long s_itb_per_group;
         unsigned long s_gdb_count;
         unsigned long s_desc_per_block;
         unsigned long s_groups_count;
         struct buffer_head * s_sbh;
         struct ext2_super_block * s_es;
         struct buffer_head ** s_group_desc;
         unsigned short s_loaded_inode_bitmaps;
         unsigned short s_loaded_block_bitmaps;
         unsigned long s_inode_bitmap_number[8];
         struct buffer_head * s_inode_bitmap[8];
         unsigned long s_block_bitmap_number[8];
         struct buffer_head * s_block_bitmap[8];
         unsigned long s_mount_opt;
         uid_t s_resuid;
         gid_t s_resgid;
         unsigned short s_mount_state;
         unsigned short s_pad;
         int s_addr_per_block_bits;
         int s_desc_per_block_bits;
         int s_inode_size;
         int s_first_ino;
         u32 s_next_generation;
 };
 # 669 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ext3_fs_sb.h" 1
 # 20 "/data1/src/linux/include/linux/ext3_fs_sb.h"
 # 1 "/data1/src/linux/include/linux/timer.h" 1
 # 16 "/data1/src/linux/include/linux/timer.h"
 struct timer_list {
         struct list_head list;
         unsigned long expires;
         unsigned long data;
         void (*function)(unsigned long);
 };
 
 extern void add_timer(struct timer_list * timer);
 extern int del_timer(struct timer_list * timer);
 
 
 extern int del_timer_sync(struct timer_list * timer);
 extern void sync_timers(void);
 # 41 "/data1/src/linux/include/linux/timer.h"
 int mod_timer(struct timer_list *timer, unsigned long expires);
 
 extern void it_real_fn(unsigned long);
 
 static inline void init_timer(struct timer_list * timer)
 {
         timer->list.next = timer->list.prev = ((void *)0);
 }
 
 static inline int timer_pending (const struct timer_list * timer)
 {
         return timer->list.next != ((void *)0);
 }
 # 21 "/data1/src/linux/include/linux/ext3_fs_sb.h" 2
 # 35 "/data1/src/linux/include/linux/ext3_fs_sb.h"
 struct ext3_sb_info {
         unsigned long s_frag_size;
         unsigned long s_frags_per_block;
         unsigned long s_inodes_per_block;
         unsigned long s_frags_per_group;
         unsigned long s_blocks_per_group;
         unsigned long s_inodes_per_group;
         unsigned long s_itb_per_group;
         unsigned long s_gdb_count;
         unsigned long s_desc_per_block;
         unsigned long s_groups_count;
         struct buffer_head * s_sbh;
         struct ext3_super_block * s_es;
         struct buffer_head ** s_group_desc;
         unsigned short s_loaded_inode_bitmaps;
         unsigned short s_loaded_block_bitmaps;
         unsigned long s_inode_bitmap_number[8];
         struct buffer_head * s_inode_bitmap[8];
         unsigned long s_block_bitmap_number[8];
         struct buffer_head * s_block_bitmap[8];
         unsigned long s_mount_opt;
         uid_t s_resuid;
         gid_t s_resgid;
         unsigned short s_mount_state;
         unsigned short s_pad;
         int s_addr_per_block_bits;
         int s_desc_per_block_bits;
         int s_inode_size;
         int s_first_ino;
 
 
         struct inode * s_journal_inode;
         struct journal_s * s_journal;
         struct list_head s_orphan;
         unsigned long s_commit_interval;
         struct block_device *journal_bdev;
 
 
 
 
 };
 # 670 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/hpfs_fs_sb.h" 1
 
 
 
 struct hpfs_sb_info {
         ino_t sb_root;
         unsigned sb_fs_size;
         unsigned sb_bitmaps;
         unsigned sb_dirband_start;
         unsigned sb_dirband_size;
         unsigned sb_dmap;
         unsigned sb_n_free;
         unsigned sb_n_free_dnodes;
         uid_t sb_uid;
         gid_t sb_gid;
         umode_t sb_mode;
         unsigned sb_conv : 2;
         unsigned sb_eas : 2;
         unsigned sb_err : 2;
         unsigned sb_chk : 2;
         unsigned sb_lowercase : 1;
         unsigned sb_was_error : 1;
         unsigned sb_chkdsk : 2;
         unsigned sb_rd_fnode : 2;
         unsigned sb_rd_inode : 2;
 
 
         wait_queue_head_t sb_iget_q;
         unsigned char *sb_cp_table;
 
 
         unsigned *sb_bmp_dir;
         unsigned sb_c_bitmap;
         wait_queue_head_t sb_creation_de;
 
         unsigned sb_creation_de_lock : 1;
 
         int sb_timeshift;
 };
 # 671 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ntfs_fs_sb.h" 1
 
 
 
 
 
 struct ntfs_sb_info{
 
         ntfs_uid_t uid;
         ntfs_gid_t gid;
         ntmode_t umask;
         void *nls_map;
         unsigned int ngt;
         char mft_zone_multiplier;
         unsigned long mft_data_pos;
         ntfs_cluster_t mft_zone_pos;
         ntfs_cluster_t mft_zone_start;
         ntfs_cluster_t mft_zone_end;
         ntfs_cluster_t data1_zone_pos;
         ntfs_cluster_t data2_zone_pos;
 
 
         ntfs_size_t partition_bias;
 
         ntfs_u32 at_standard_information;
         ntfs_u32 at_attribute_list;
         ntfs_u32 at_file_name;
         ntfs_u32 at_volume_version;
         ntfs_u32 at_security_descriptor;
         ntfs_u32 at_volume_name;
         ntfs_u32 at_volume_information;
         ntfs_u32 at_data;
         ntfs_u32 at_index_root;
         ntfs_u32 at_index_allocation;
         ntfs_u32 at_bitmap;
         ntfs_u32 at_symlink;
 
         int sector_size;
         int cluster_size;
         int cluster_size_bits;
         int mft_clusters_per_record;
         int mft_record_size;
         int mft_record_size_bits;
         int index_clusters_per_record;
         int index_record_size;
         int index_record_size_bits;
         ntfs_cluster_t nr_clusters;
         ntfs_cluster_t mft_lcn;
         ntfs_cluster_t mft_mirr_lcn;
 
         unsigned char *mft;
         unsigned short *upcase;
         unsigned int upcase_length;
 
         struct ntfs_inode_info *mft_ino;
         struct ntfs_inode_info *mftmirr;
         struct ntfs_inode_info *bitmap;
         struct super_block *sb;
         unsigned char ino_flags;
 };
 # 672 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/msdos_fs_sb.h" 1
 
 
 # 1 "/data1/src/linux/include/linux/fat_cvf.h" 1
 
 
 
 
 
 struct cvf_format
 { int cvf_version;
   char* cvf_version_text;
   unsigned long flags;
   int (*detect_cvf) (struct super_block*sb);
   int (*mount_cvf) (struct super_block*sb,char*options);
   int (*unmount_cvf) (struct super_block*sb);
   struct buffer_head* (*cvf_bread) (struct super_block*sb,int block);
   struct buffer_head* (*cvf_getblk) (struct super_block*sb,int block);
   void (*cvf_brelse) (struct super_block *sb,struct buffer_head *bh);
   void (*cvf_mark_buffer_dirty) (struct super_block *sb,
                               struct buffer_head *bh);
   void (*cvf_set_uptodate) (struct super_block *sb,
                          struct buffer_head *bh,
                          int val);
   int (*cvf_is_uptodate) (struct super_block *sb,struct buffer_head *bh);
   void (*cvf_ll_rw_block) (struct super_block *sb,
                         int opr,
                         int nbreq,
                         struct buffer_head *bh[32]);
   int (*fat_access) (struct super_block *sb,int nr,int new_value);
   int (*cvf_statfs) (struct super_block *sb,struct statfs *buf, int bufsiz);
   int (*cvf_bmap) (struct inode *inode,int block);
   ssize_t (*cvf_file_read) ( struct file *, char *, size_t, loff_t *);
   ssize_t (*cvf_file_write) ( struct file *, const char *, size_t, loff_t *);
   int (*cvf_mmap) (struct file *, struct vm_area_struct *);
   int (*cvf_readpage) (struct inode *, struct page *);
   int (*cvf_writepage) (struct inode *, struct page *);
   int (*cvf_dir_ioctl) (struct inode * inode, struct file * filp,
                         unsigned int cmd, unsigned long arg);
   void (*zero_out_cluster) (struct inode*, int clusternr);
 };
 
 int register_cvf_format(struct cvf_format*cvf_format);
 int unregister_cvf_format(struct cvf_format*cvf_format);
 void dec_cvf_format_use_count_by_version(int version);
 int detect_cvf(struct super_block*sb,char*force);
 
 extern struct cvf_format *cvf_formats[];
 extern int cvf_format_use_count[];
 # 4 "/data1/src/linux/include/linux/msdos_fs_sb.h" 2
 
 
 
 
 
 struct fat_mount_options {
         uid_t fs_uid;
         gid_t fs_gid;
         unsigned short fs_umask;
         unsigned short codepage;
         char *iocharset;
         unsigned short shortname;
         unsigned char name_check;
         unsigned char conversion;
         unsigned quiet:1,
                  showexec:1,
                  sys_immutable:1,
                  dotsOK:1,
                  isvfat:1,
                  utf8:1,
                  unicode_xlate:1,
                  posixfs:1,
                  numtail:1,
                  atari:1,
                  fat32:1,
                  nocase:1;
 };
 
 struct msdos_sb_info {
         unsigned short cluster_size;
         unsigned short cluster_bits;
         unsigned char fats,fat_bits;
         unsigned short fat_start;
         unsigned long fat_length;
         unsigned long dir_start;
         unsigned short dir_entries;
         unsigned long data_start;
         unsigned long clusters;
         unsigned long root_cluster;
         unsigned long fsinfo_sector;
         struct semaphore fat_lock;
         int prev_free;
         int free_clusters;
         struct fat_mount_options options;
         struct nls_table *nls_disk;
         struct nls_table *nls_io;
         struct cvf_format* cvf_format;
         void *dir_ops;
         void *private_data;
         int dir_per_block;
         int dir_per_block_bits;
 };
 # 673 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/iso_fs_sb.h" 1
 
 
 
 
 
 
 struct isofs_sb_info {
         unsigned long s_ninodes;
         unsigned long s_nzones;
         unsigned long s_firstdatazone;
         unsigned long s_log_zone_size;
         unsigned long s_max_size;
 
         unsigned char s_high_sierra;
         unsigned char s_mapping;
         int s_rock_offset;
         unsigned char s_rock;
         unsigned char s_joliet_level;
         unsigned char s_utf8;
         unsigned char s_cruft;
 
 
         unsigned char s_unhide;
         unsigned char s_nosuid;
         unsigned char s_nodev;
         unsigned char s_nocompress;
 
         mode_t s_mode;
         gid_t s_gid;
         uid_t s_uid;
         struct nls_table *s_nls_iocharset;
 };
 # 674 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/nfs_fs_sb.h" 1
 # 9 "/data1/src/linux/include/linux/nfs_fs_sb.h"
 struct nfs_server {
         struct rpc_clnt * client;
         struct nfs_rpc_ops * rpc_ops;
         int flags;
         unsigned int rsize;
         unsigned int rpages;
         unsigned int wsize;
         unsigned int wpages;
         unsigned int dtsize;
         unsigned int bsize;
         unsigned int acregmin;
         unsigned int acregmax;
         unsigned int acdirmin;
         unsigned int acdirmax;
         unsigned int namelen;
         char * hostname;
         struct nfs_reqlist * rw_requests;
         struct list_head lru_read,
                                 lru_dirty,
                                 lru_commit,
                                 lru_busy;
 };
 
 
 
 
 struct nfs_sb_info {
         struct nfs_server s_server;
 };
 # 675 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/sysv_fs_sb.h" 1
 # 13 "/data1/src/linux/include/linux/sysv_fs_sb.h"
 struct sysv_sb_info {
         int s_type;
         char s_bytesex;
         char s_truncate;
 
         nlink_t s_link_max;
         unsigned int s_inodes_per_block;
         unsigned int s_inodes_per_block_1;
         unsigned int s_inodes_per_block_bits;
         unsigned int s_ind_per_block;
         unsigned int s_ind_per_block_bits;
         unsigned int s_ind_per_block_2;
         unsigned int s_toobig_block;
         unsigned int s_block_base;
         unsigned short s_fic_size;
         unsigned short s_flc_size;
 
         struct buffer_head *s_bh1;
         struct buffer_head *s_bh2;
 
 
         char * s_sbd1;
         char * s_sbd2;
         u16 *s_sb_fic_count;
         u16 *s_sb_fic_inodes;
         u16 *s_sb_total_free_inodes;
         u16 *s_bcache_count;
         u32 *s_bcache;
         u32 *s_free_blocks;
         u32 *s_sb_time;
         u32 *s_sb_state;
 
 
         u32 s_firstinodezone;
         u32 s_firstdatazone;
         u32 s_ninodes;
         u32 s_ndatazones;
         u32 s_nzones;
         u16 s_namelen;
 };
 # 676 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/affs_fs_sb.h" 1
 # 11 "/data1/src/linux/include/linux/affs_fs_sb.h"
 struct affs_bm_info {
         u32 bm_key;
         u32 bm_free;
 };
 
 struct affs_sb_info {
         int s_partition_size;
         int s_reserved;
 
         u32 s_data_blksize;
         u32 s_root_block;
         int s_hashsize;
         unsigned long s_flags;
         uid_t s_uid;
         gid_t s_gid;
         umode_t s_mode;
         struct buffer_head *s_root_bh;
         struct semaphore s_bmlock;
         struct affs_bm_info *s_bitmap;
         u32 s_bmap_count;
         u32 s_bmap_bits;
         u32 s_last_bmap;
         struct buffer_head *s_bmap_bh;
         char *s_prefix;
         int s_prefix_len;
         char s_volume[32];
 };
 # 677 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ufs_fs_sb.h" 1
 # 17 "/data1/src/linux/include/linux/ufs_fs_sb.h"
 # 1 "/data1/src/linux/include/linux/ufs_fs.h" 1
 # 237 "/data1/src/linux/include/linux/ufs_fs.h"
 struct ufs_timeval {
         __s32 tv_sec;
         __s32 tv_usec;
 };
 
 struct ufs_dir_entry {
         __u32 d_ino;
         __u16 d_reclen;
         union {
                 __u16 d_namlen;
                 struct {
                         __u8 d_type;
                         __u8 d_namlen;
                 } d_44;
         } d_u;
         __u8 d_name[255 + 1];
 };
 
 struct ufs_csum {
         __u32 cs_ndir;
         __u32 cs_nbfree;
         __u32 cs_nifree;
         __u32 cs_nffree;
 };
 
 
 
 
 struct ufs_super_block {
         __u32 fs_link;
         __u32 fs_rlink;
         __u32 fs_sblkno;
         __u32 fs_cblkno;
         __u32 fs_iblkno;
         __u32 fs_dblkno;
         __u32 fs_cgoffset;
         __u32 fs_cgmask;
         __u32 fs_time;
         __u32 fs_size;
         __u32 fs_dsize;
         __u32 fs_ncg;
         __u32 fs_bsize;
         __u32 fs_fsize;
         __u32 fs_frag;
 
         __u32 fs_minfree;
         __u32 fs_rotdelay;
         __u32 fs_rps;
 
         __u32 fs_bmask;
         __u32 fs_fmask;
         __u32 fs_bshift;
         __u32 fs_fshift;
 
         __u32 fs_maxcontig;
         __u32 fs_maxbpg;
 
         __u32 fs_fragshift;
         __u32 fs_fsbtodb;
         __u32 fs_sbsize;
         __u32 fs_csmask;
         __u32 fs_csshift;
         __u32 fs_nindir;
         __u32 fs_inopb;
         __u32 fs_nspf;
 
         __u32 fs_optim;
 
         union {
                 struct {
                         __u32 fs_npsect;
                 } fs_sun;
                 struct {
                         __s32 fs_state;
                 } fs_sunx86;
         } fs_u1;
         __u32 fs_interleave;
         __u32 fs_trackskew;
 
 
 
 
         __u32 fs_id[2];
 
         __u32 fs_csaddr;
         __u32 fs_cssize;
         __u32 fs_cgsize;
 
         __u32 fs_ntrak;
         __u32 fs_nsect;
         __u32 fs_spc;
 
         __u32 fs_ncyl;
 
         __u32 fs_cpg;
         __u32 fs_ipg;
         __u32 fs_fpg;
 
         struct ufs_csum fs_cstotal;
 
         __s8 fs_fmod;
         __s8 fs_clean;
         __s8 fs_ronly;
         __s8 fs_flags;
         __s8 fs_fsmnt[512];
 
         __u32 fs_cgrotor;
         __u32 fs_csp[31];
         __u32 fs_maxcluster;
         __u32 fs_cpc;
         __u16 fs_opostbl[16][8];
         union {
                 struct {
                         __s32 fs_sparecon[53];
                         __s32 fs_reclaim;
                         __s32 fs_sparecon2[1];
                         __s32 fs_state;
                         __u32 fs_qbmask[2];
                         __u32 fs_qfmask[2];
                 } fs_sun;
                 struct {
                         __s32 fs_sparecon[53];
                         __s32 fs_reclaim;
                         __s32 fs_sparecon2[1];
                         __u32 fs_npsect;
                         __u32 fs_qbmask[2];
                         __u32 fs_qfmask[2];
                 } fs_sunx86;
                 struct {
                         __s32 fs_sparecon[50];
                         __s32 fs_contigsumsize;
                         __s32 fs_maxsymlinklen;
                         __s32 fs_inodefmt;
                         __u32 fs_maxfilesize[2];
                         __u32 fs_qbmask[2];
                         __u32 fs_qfmask[2];
                         __s32 fs_state;
                 } fs_44;
         } fs_u2;
         __s32 fs_postblformat;
         __s32 fs_nrpos;
         __s32 fs_postbloff;
         __s32 fs_rotbloff;
         __s32 fs_magic;
         __u8 fs_space[1];
 };
 # 415 "/data1/src/linux/include/linux/ufs_fs.h"
 struct ufs_cylinder_group {
         __u32 cg_link;
         __u32 cg_magic;
         __u32 cg_time;
         __u32 cg_cgx;
         __u16 cg_ncyl;
         __u16 cg_niblk;
         __u32 cg_ndblk;
         struct ufs_csum cg_cs;
         __u32 cg_rotor;
         __u32 cg_frotor;
         __u32 cg_irotor;
         __u32 cg_frsum[(8192 / 1024)];
         __u32 cg_btotoff;
         __u32 cg_boff;
         __u32 cg_iusedoff;
         __u32 cg_freeoff;
         __u32 cg_nextfreeoff;
         union {
                 struct {
                         __u32 cg_clustersumoff;
                         __u32 cg_clusteroff;
                         __u32 cg_nclusterblks;
                         __u32 cg_sparecon[13];
                 } cg_44;
                 __u32 cg_sparecon[16];
         } cg_u;
         __u8 cg_space[1];
 
 };
 
 
 
 
 struct ufs_inode {
         __u16 ui_mode;
         __u16 ui_nlink;
         union {
                 struct {
                         __u16 ui_suid;
                         __u16 ui_sgid;
                 } oldids;
                 __u32 ui_inumber;
                 __u32 ui_author;
         } ui_u1;
         __u64 ui_size;
         struct ufs_timeval ui_atime;
         struct ufs_timeval ui_mtime;
         struct ufs_timeval ui_ctime;
         union {
                 struct {
                         __u32 ui_db[12];
                         __u32 ui_ib[3];
                 } ui_addr;
                 __u8 ui_symlink[4*(12 +3)];
         } ui_u2;
         __u32 ui_flags;
         __u32 ui_blocks;
         __u32 ui_gen;
         union {
                 struct {
                         __u32 ui_shadow;
                         __u32 ui_uid;
                         __u32 ui_gid;
                         __u32 ui_oeftflag;
                 } ui_sun;
                 struct {
                         __u32 ui_uid;
                         __u32 ui_gid;
                         __s32 ui_spare[2];
                 } ui_44;
                 struct {
                         __u32 ui_uid;
                         __u32 ui_gid;
                         __u16 ui_modeh;
                         __u16 ui_spare;
                         __u32 ui_trans;
                 } ui_hurd;
         } ui_u3;
 };
 # 514 "/data1/src/linux/include/linux/ufs_fs.h"
 extern void ufs_free_fragments (struct inode *, unsigned, unsigned);
 extern void ufs_free_blocks (struct inode *, unsigned, unsigned);
 extern unsigned ufs_new_fragments (struct inode *, u32 *, unsigned, unsigned, unsigned, int *);
 
 
 extern struct ufs_cg_private_info * ufs_load_cylinder (struct super_block *, unsigned);
 extern void ufs_put_cylinder (struct super_block *, unsigned);
 
 
 extern struct inode_operations ufs_dir_inode_operations;
 extern int ufs_check_dir_entry (const char *, struct inode *, struct ufs_dir_entry *, struct buffer_head *, unsigned long);
 extern int ufs_add_link (struct dentry *, struct inode *);
 extern ino_t ufs_inode_by_name(struct inode *, struct dentry *);
 extern int ufs_make_empty(struct inode *, struct inode *);
 extern struct ufs_dir_entry * ufs_find_entry (struct dentry *, struct buffer_head **);
 extern int ufs_delete_entry (struct inode *, struct ufs_dir_entry *, struct buffer_head *);
 extern int ufs_empty_dir (struct inode *);
 extern struct ufs_dir_entry * ufs_dotdot (struct inode *, struct buffer_head **);
 extern void ufs_set_link(struct inode *, struct ufs_dir_entry *, struct buffer_head *, struct inode *);
 
 
 extern struct inode_operations ufs_file_inode_operations;
 extern struct file_operations ufs_file_operations;
 
 extern struct address_space_operations ufs_aops;
 
 
 extern void ufs_free_inode (struct inode *inode);
 extern struct inode * ufs_new_inode (const struct inode *, int);
 
 
 extern int ufs_frag_map (struct inode *, int);
 extern void ufs_read_inode (struct inode *);
 extern void ufs_put_inode (struct inode *);
 extern void ufs_write_inode (struct inode *, int);
 extern int ufs_sync_inode (struct inode *);
 extern void ufs_delete_inode (struct inode *);
 extern struct buffer_head * ufs_getfrag (struct inode *, unsigned, int, int *);
 extern struct buffer_head * ufs_bread (struct inode *, unsigned, int, int *);
 
 
 extern struct file_operations ufs_dir_operations;
 
 
 extern struct file_system_type ufs_fs_type;
 extern void ufs_warning (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
 extern void ufs_error (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
 extern void ufs_panic (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
 extern void ufs_write_super (struct super_block *);
 
 
 extern struct inode_operations ufs_fast_symlink_inode_operations;
 
 
 extern void ufs_truncate (struct inode *);
 # 18 "/data1/src/linux/include/linux/ufs_fs_sb.h" 2
 
 
 
 
 
 struct ufs_buffer_head {
         unsigned fragment;
         unsigned count;
         struct buffer_head * bh[(8192 / 1024)];
 };
 
 struct ufs_cg_private_info {
         struct ufs_cylinder_group ucg;
         __u32 c_cgx;
         __u16 c_ncyl;
         __u16 c_niblk;
         __u32 c_ndblk;
         __u32 c_rotor;
         __u32 c_frotor;
         __u32 c_irotor;
         __u32 c_btotoff;
         __u32 c_boff;
         __u32 c_iusedoff;
         __u32 c_freeoff;
         __u32 c_nextfreeoff;
         __u32 c_clustersumoff;
         __u32 c_clusteroff;
         __u32 c_nclusterblks;
 };
 
 struct ufs_sb_private_info {
         struct ufs_buffer_head s_ubh;
         __u32 s_sblkno;
         __u32 s_cblkno;
         __u32 s_iblkno;
         __u32 s_dblkno;
         __u32 s_cgoffset;
         __u32 s_cgmask;
         __u32 s_size;
         __u32 s_dsize;
         __u32 s_ncg;
         __u32 s_bsize;
         __u32 s_fsize;
         __u32 s_fpb;
         __u32 s_minfree;
         __u32 s_bmask;
         __u32 s_fmask;
         __u32 s_bshift;
         __u32 s_fshift;
         __u32 s_fpbshift;
         __u32 s_fsbtodb;
         __u32 s_sbsize;
         __u32 s_csmask;
         __u32 s_csshift;
         __u32 s_nindir;
         __u32 s_inopb;
         __u32 s_nspf;
         __u32 s_npsect;
         __u32 s_interleave;
         __u32 s_trackskew;
         __u32 s_csaddr;
         __u32 s_cssize;
         __u32 s_cgsize;
         __u32 s_ntrak;
         __u32 s_nsect;
         __u32 s_spc;
         __u32 s_ipg;
         __u32 s_fpg;
         __u32 s_cpc;
         __s32 s_contigsumsize;
         __s64 s_qbmask;
         __s64 s_qfmask;
         __s32 s_postblformat;
         __s32 s_nrpos;
         __s32 s_postbloff;
         __s32 s_rotbloff;
 
         __u32 s_fpbmask;
         __u32 s_apb;
         __u32 s_2apb;
         __u32 s_3apb;
         __u32 s_apbmask;
         __u32 s_apbshift;
         __u32 s_2apbshift;
         __u32 s_3apbshift;
         __u32 s_nspfshift;
         __u32 s_nspb;
         __u32 s_inopf;
         __u32 s_sbbase;
         __u32 s_bpf;
         __u32 s_bpfshift;
         __u32 s_bpfmask;
 
         __u32 s_maxsymlinklen;
 };
 
 
 
 
 
 struct ufs_sb_info {
         struct ufs_sb_private_info * s_uspi;
         struct ufs_csum * s_csp[31];
         unsigned s_bytesex;
         unsigned s_flags;
         struct buffer_head ** s_ucg;
         struct ufs_cg_private_info * s_ucpi[8];
         unsigned s_cgno[8];
         unsigned short s_cg_loaded;
         unsigned s_mount_opt;
 };
 
 
 
 
 
 
 
 struct ufs_super_block_first {
         __u32 fs_link;
         __u32 fs_rlink;
         __u32 fs_sblkno;
         __u32 fs_cblkno;
         __u32 fs_iblkno;
         __u32 fs_dblkno;
         __u32 fs_cgoffset;
         __u32 fs_cgmask;
         __u32 fs_time;
         __u32 fs_size;
         __u32 fs_dsize;
         __u32 fs_ncg;
         __u32 fs_bsize;
         __u32 fs_fsize;
         __u32 fs_frag;
         __u32 fs_minfree;
         __u32 fs_rotdelay;
         __u32 fs_rps;
         __u32 fs_bmask;
         __u32 fs_fmask;
         __u32 fs_bshift;
         __u32 fs_fshift;
         __u32 fs_maxcontig;
         __u32 fs_maxbpg;
         __u32 fs_fragshift;
         __u32 fs_fsbtodb;
         __u32 fs_sbsize;
         __u32 fs_csmask;
         __u32 fs_csshift;
         __u32 fs_nindir;
         __u32 fs_inopb;
         __u32 fs_nspf;
         __u32 fs_optim;
         union {
                 struct {
                         __u32 fs_npsect;
                 } fs_sun;
                 struct {
                         __s32 fs_state;
                 } fs_sunx86;
         } fs_u1;
         __u32 fs_interleave;
         __u32 fs_trackskew;
         __u32 fs_id[2];
         __u32 fs_csaddr;
         __u32 fs_cssize;
         __u32 fs_cgsize;
         __u32 fs_ntrak;
         __u32 fs_nsect;
         __u32 fs_spc;
         __u32 fs_ncyl;
         __u32 fs_cpg;
         __u32 fs_ipg;
         __u32 fs_fpg;
         struct ufs_csum fs_cstotal;
         __s8 fs_fmod;
         __s8 fs_clean;
         __s8 fs_ronly;
         __s8 fs_flags;
         __s8 fs_fsmnt[512 - 212];
 
 };
 
 struct ufs_super_block_second {
         __s8 fs_fsmnt[212];
         __u32 fs_cgrotor;
         __u32 fs_csp[31];
         __u32 fs_maxcluster;
         __u32 fs_cpc;
         __u16 fs_opostbl[82];
 };
 
 struct ufs_super_block_third {
         __u16 fs_opostbl[46];
         union {
                 struct {
                         __s32 fs_sparecon[53];
                         __s32 fs_reclaim;
                         __s32 fs_sparecon2[1];
                         __s32 fs_state;
                         __u32 fs_qbmask[2];
                         __u32 fs_qfmask[2];
                 } fs_sun;
                 struct {
                         __s32 fs_sparecon[53];
                         __s32 fs_reclaim;
                         __s32 fs_sparecon2[1];
                         __u32 fs_npsect;
                         __u32 fs_qbmask[2];
                         __u32 fs_qfmask[2];
                 } fs_sunx86;
                 struct {
                         __s32 fs_sparecon[50];
                         __s32 fs_contigsumsize;
                         __s32 fs_maxsymlinklen;
                         __s32 fs_inodefmt;
                         __u32 fs_maxfilesize[2];
                         __u32 fs_qbmask[2];
                         __u32 fs_qfmask[2];
                         __s32 fs_state;
                 } fs_44;
         } fs_u2;
         __s32 fs_postblformat;
         __s32 fs_nrpos;
         __s32 fs_postbloff;
         __s32 fs_rotbloff;
         __s32 fs_magic;
         __u8 fs_space[1];
 };
 # 678 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/efs_fs_sb.h" 1
 # 25 "/data1/src/linux/include/linux/efs_fs_sb.h"
 struct efs_super {
         int32_t fs_size;
         int32_t fs_firstcg;
         int32_t fs_cgfsize;
         short fs_cgisize;
         short fs_sectors;
         short fs_heads;
         short fs_ncg;
         short fs_dirty;
         int32_t fs_time;
         int32_t fs_magic;
         char fs_fname[6];
         char fs_fpack[6];
         int32_t fs_bmsize;
         int32_t fs_tfree;
         int32_t fs_tinode;
         int32_t fs_bmblock;
         int32_t fs_replsb;
         int32_t fs_lastialloc;
         char fs_spare[20];
         int32_t fs_checksum;
 };
 
 
 struct efs_sb_info {
         int32_t fs_magic;
         int32_t fs_start;
         int32_t first_block;
         int32_t total_blocks;
         int32_t group_size;
         int32_t data_free;
         int32_t inode_free;
         short inode_blocks;
         short total_groups;
 };
 # 679 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/romfs_fs_sb.h" 1
 
 
 
 
 
 struct romfs_sb_info {
         unsigned long s_maxsize;
 };
 # 680 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/smb_fs_sb.h" 1
 # 15 "/data1/src/linux/include/linux/smb_fs_sb.h"
 # 1 "/data1/src/linux/include/linux/smb.h" 1
 # 14 "/data1/src/linux/include/linux/smb.h"
 enum smb_protocol {
         SMB_PROTOCOL_NONE,
         SMB_PROTOCOL_CORE,
         SMB_PROTOCOL_COREPLUS,
         SMB_PROTOCOL_LANMAN1,
         SMB_PROTOCOL_LANMAN2,
         SMB_PROTOCOL_NT1
 };
 
 enum smb_case_hndl {
         SMB_CASE_DEFAULT,
         SMB_CASE_LOWER,
         SMB_CASE_UPPER
 };
 
 struct smb_dskattr {
         __u16 total;
         __u16 allocblocks;
         __u16 blocksize;
         __u16 free;
 };
 
 struct smb_conn_opt {
 
 
         unsigned int fd;
 
         enum smb_protocol protocol;
         enum smb_case_hndl case_handling;
 
 
 
         __u32 max_xmit;
         __u16 server_uid;
         __u16 tid;
 
 
         __u16 secmode;
         __u16 maxmux;
         __u16 maxvcs;
         __u16 rawmode;
         __u32 sesskey;
 
 
         __u32 maxraw;
         __u32 capabilities;
         __s16 serverzone;
 };
 
 
 
 
 struct smb_nls_codepage {
         char local_name[20];
         char remote_name[20];
 };
 # 78 "/data1/src/linux/include/linux/smb.h"
 struct smb_fattr {
 
         __u16 attr;
 
         unsigned long f_ino;
         umode_t f_mode;
         nlink_t f_nlink;
         uid_t f_uid;
         gid_t f_gid;
         kdev_t f_rdev;
         off_t f_size;
         time_t f_atime;
         time_t f_mtime;
         time_t f_ctime;
         unsigned long f_blksize;
         unsigned long f_blocks;
 };
 
 enum smb_conn_state {
         CONN_VALID,
         CONN_INVALID,
 
         CONN_RETRIED,
         CONN_RETRYING
 };
 # 16 "/data1/src/linux/include/linux/smb_fs_sb.h" 2
 
 
 
 
 
 
 
 struct smb_sb_info {
         enum smb_conn_state state;
         struct file * sock_file;
 
         struct smb_mount_data_kernel *mnt;
         unsigned char *temp_buf;
 
 
 
 
         unsigned int generation;
         pid_t conn_pid;
         struct smb_conn_opt opt;
 
         struct semaphore sem;
         wait_queue_head_t wait;
 
         __u32 packet_size;
         unsigned char * packet;
         unsigned short rcls;
         unsigned short err;
 
 
         void *data_ready;
 
 
         struct nls_table *remote_nls;
         struct nls_table *local_nls;
 
 
 
 
         char *name_buf;
 
         int (*convert)(char *, int, const char *, int,
                        struct nls_table *, struct nls_table *);
 };
 
 
 static inline void
 smb_lock_server(struct smb_sb_info *server)
 {
         down(&(server->sem));
 }
 
 static inline void
 smb_unlock_server(struct smb_sb_info *server)
 {
         up(&(server->sem));
 }
 # 681 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/hfs_fs_sb.h" 1
 # 15 "/data1/src/linux/include/linux/hfs_fs_sb.h"
 struct hfs_name;
 
 typedef int (*hfs_namein_fn) (char *, const struct hfs_name *);
 typedef void (*hfs_nameout_fn) (struct hfs_name *, const char *, int);
 typedef void (*hfs_ifill_fn) (struct inode *, ino_t, const int);
 
 
 
 
 
 
 struct hfs_sb_info {
         int magic;
         struct hfs_mdb *s_mdb;
         int s_quiet;
 
         int s_lowercase;
         int s_afpd;
         int s_version;
         hfs_namein_fn s_namein;
 
 
         hfs_nameout_fn s_nameout;
 
 
         hfs_ifill_fn s_ifill;
 
         const struct hfs_name *s_reserved1;
         const struct hfs_name *s_reserved2;
         __u32 s_type;
         __u32 s_creator;
         umode_t s_umask;
 
         uid_t s_uid;
         gid_t s_gid;
         char s_conv;
 };
 # 682 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/adfs_fs_sb.h" 1
 # 13 "/data1/src/linux/include/linux/adfs_fs_sb.h"
 struct adfs_discmap;
 struct adfs_dir_ops;
 
 
 
 
 struct adfs_sb_info {
         struct adfs_discmap *s_map;
         struct adfs_dir_ops *s_dir;
 
         uid_t s_uid;
         gid_t s_gid;
         umode_t s_owner_mask;
         umode_t s_other_mask;
 
         __u32 s_ids_per_zone;
         __u32 s_idlen;
         __u32 s_map_size;
         unsigned long s_size;
         signed int s_map2blk;
         unsigned int s_log2sharesize;
         unsigned int s_version;
         unsigned int s_namelen;
 };
 # 683 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/qnx4_fs_sb.h" 1
 # 14 "/data1/src/linux/include/linux/qnx4_fs_sb.h"
 # 1 "/data1/src/linux/include/linux/qnx4_fs.h" 1
 # 45 "/data1/src/linux/include/linux/qnx4_fs.h"
 struct qnx4_inode_entry {
         char di_fname[16];
         qnx4_off_t di_size;
         qnx4_xtnt_t di_first_xtnt;
         __u32 di_xblk;
         __s32 di_ftime;
         __s32 di_mtime;
         __s32 di_atime;
         __s32 di_ctime;
         qnx4_nxtnt_t di_num_xtnts;
         qnx4_mode_t di_mode;
         qnx4_muid_t di_uid;
         qnx4_mgid_t di_gid;
         qnx4_nlink_t di_nlink;
         __u8 di_zero[4];
         qnx4_ftype_t di_type;
         __u8 di_status;
 };
 
 struct qnx4_link_info {
         char dl_fname[48];
         __u32 dl_inode_blk;
         __u8 dl_inode_ndx;
         __u8 dl_spare[10];
         __u8 dl_status;
 };
 
 struct qnx4_xblk {
         __u32 xblk_next_xblk;
         __u32 xblk_prev_xblk;
         __u8 xblk_num_xtnts;
         __u8 xblk_spare[3];
         __s32 xblk_num_blocks;
         qnx4_xtnt_t xblk_xtnts[60];
         char xblk_signature[8];
         qnx4_xtnt_t xblk_first_xtnt;
 };
 
 struct qnx4_super_block {
         struct qnx4_inode_entry RootDir;
         struct qnx4_inode_entry Inode;
         struct qnx4_inode_entry Boot;
         struct qnx4_inode_entry AltBoot;
 };
 # 100 "/data1/src/linux/include/linux/qnx4_fs.h"
 extern struct dentry *qnx4_lookup(struct inode *dir, struct dentry *dentry);
 extern unsigned long qnx4_count_free_blocks(struct super_block *sb);
 extern unsigned long qnx4_block_map(struct inode *inode, long iblock);
 
 extern struct buffer_head *qnx4_getblk(struct inode *, int, int);
 extern struct buffer_head *qnx4_bread(struct inode *, int, int);
 
 extern int qnx4_create(struct inode *dir, struct dentry *dentry, int mode);
 extern struct inode_operations qnx4_file_inode_operations;
 extern struct inode_operations qnx4_dir_inode_operations;
 extern struct file_operations qnx4_file_operations;
 extern struct file_operations qnx4_dir_operations;
 extern int qnx4_is_free(struct super_block *sb, long block);
 extern int qnx4_set_bitmap(struct super_block *sb, long block, int busy);
 extern int qnx4_create(struct inode *inode, struct dentry *dentry, int mode);
 extern void qnx4_truncate(struct inode *inode);
 extern void qnx4_free_inode(struct inode *inode);
 extern int qnx4_unlink(struct inode *dir, struct dentry *dentry);
 extern int qnx4_rmdir(struct inode *dir, struct dentry *dentry);
 extern int qnx4_sync_file(struct file *file, struct dentry *dentry, int);
 extern int qnx4_sync_inode(struct inode *inode);
 extern int qnx4_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh, int create);
 # 15 "/data1/src/linux/include/linux/qnx4_fs_sb.h" 2
 
 
 
 
 
 struct qnx4_sb_info {
         struct buffer_head *sb_buf;
         struct qnx4_super_block *sb;
         unsigned int Version;
         struct qnx4_inode_entry *BitMap;
 };
 # 684 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/reiserfs_fs_sb.h" 1
 
 
 
 
 
 
 
 # 1 "/data1/src/linux/include/linux/tqueue.h" 1
 # 38 "/data1/src/linux/include/linux/tqueue.h"
 struct tq_struct {
         struct list_head list;
         unsigned long sync;
         void (*routine)(void *);
         void *data;
 };
 # 64 "/data1/src/linux/include/linux/tqueue.h"
 typedef struct list_head task_queue;
 
 
 
 
 extern task_queue tq_timer, tq_immediate, tq_disk;
 # 94 "/data1/src/linux/include/linux/tqueue.h"
 extern spinlock_t tqueue_lock;
 
 
 
 
 
 static inline int queue_task(struct tq_struct *bh_pointer, task_queue *bh_list)
 {
         int ret = 0;
         if (!test_and_set_bit(0,&bh_pointer->sync)) {
                 unsigned long flags;
                 do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b  \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&tqueue_lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 list_add_tail(&bh_pointer->list, bh_list);
                 do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &tqueue_lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
                 ret = 1;
         }
         return ret;
 }
 
 
 
 
 
 extern void __run_task_queue(task_queue *list);
 
 static inline void run_task_queue(task_queue *list)
 {
         if ((!list_empty(&*list)))
                 __run_task_queue(list);
 }
 # 9 "/data1/src/linux/include/linux/reiserfs_fs_sb.h" 2
 # 26 "/data1/src/linux/include/linux/reiserfs_fs_sb.h"
 struct reiserfs_super_block
 {
   __u32 s_block_count;
   __u32 s_free_blocks;
   __u32 s_root_block;
   __u32 s_journal_block;
   __u32 s_journal_dev;
 # 43 "/data1/src/linux/include/linux/reiserfs_fs_sb.h"
   __u32 s_orig_journal_size;
   __u32 s_journal_trans_max ;
   __u32 s_journal_block_count ;
   __u32 s_journal_max_batch ;
   __u32 s_journal_max_commit_age ;
   __u32 s_journal_max_trans_age ;
   __u16 s_blocksize;
   __u16 s_oid_maxsize;
   __u16 s_oid_cursize;
   __u16 s_state;
   char s_magic[12];
   __u32 s_hash_function_code;
   __u16 s_tree_height;
   __u16 s_bmap_nr;
   __u16 s_version;
 
 
 
 
   __u16 s_reserved;
   __u32 s_inode_generation;
   char s_unused[124] ;
 } __attribute__ ((__packed__));
 # 121 "/data1/src/linux/include/linux/reiserfs_fs_sb.h"
 struct reiserfs_super_block_v1
 {
   __u32 s_block_count;
   __u32 s_free_blocks;
   __u32 s_root_block;
   __u32 s_journal_block;
   __u32 s_journal_dev;
   __u32 s_orig_journal_size;
   __u32 s_journal_trans_max ;
   __u32 s_journal_block_count ;
   __u32 s_journal_max_batch ;
   __u32 s_journal_max_commit_age ;
   __u32 s_journal_max_trans_age ;
   __u16 s_blocksize;
   __u16 s_oid_maxsize;
   __u16 s_oid_cursize;
   __u16 s_state;
   char s_magic[16];
   __u16 s_tree_height;
   __u16 s_bmap_nr;
   __u32 s_reserved;
 } __attribute__ ((__packed__));
 # 200 "/data1/src/linux/include/linux/reiserfs_fs_sb.h"
 struct reiserfs_journal_cnode {
   struct buffer_head *bh ;
   struct super_block *sb ;
   unsigned long blocknr ;
   int state ;
   struct reiserfs_journal_list *jlist ;
   struct reiserfs_journal_cnode *next ;
   struct reiserfs_journal_cnode *prev ;
   struct reiserfs_journal_cnode *hprev ;
   struct reiserfs_journal_cnode *hnext ;
 };
 
 struct reiserfs_bitmap_node {
   int id ;
   char *data ;
   struct list_head list ;
 } ;
 
 struct reiserfs_list_bitmap {
   struct reiserfs_journal_list *journal_list ;
   struct reiserfs_bitmap_node **bitmaps ;
 } ;
 
 
 
 
 struct reiserfs_transaction_handle {
 
   char *t_caller ;
   int t_blocks_logged ;
   int t_blocks_allocated ;
   unsigned long t_trans_id ;
   struct super_block *t_super ;
 
 } ;
 
 
 
 
 
 
 
 struct reiserfs_journal_list {
   unsigned long j_start ;
   unsigned long j_len ;
   atomic_t j_nonzerolen ;
   atomic_t j_commit_left ;
   atomic_t j_flushing ;
   atomic_t j_commit_flushing ;
   atomic_t j_older_commits_done ;
   unsigned long j_trans_id ;
   time_t j_timestamp ;
   struct reiserfs_list_bitmap *j_list_bitmap ;
   struct buffer_head *j_commit_bh ;
   struct reiserfs_journal_cnode *j_realblock ;
   struct reiserfs_journal_cnode *j_freedlist ;
   wait_queue_head_t j_commit_wait ;
   wait_queue_head_t j_flush_wait ;
 } ;
 
 struct reiserfs_page_list ;
 
 struct reiserfs_journal {
   struct buffer_head ** j_ap_blocks ;
   struct reiserfs_journal_cnode *j_last ;
   struct reiserfs_journal_cnode *j_first ;
 
   int j_state ;
   unsigned long j_trans_id ;
   unsigned long j_mount_id ;
   unsigned long j_start ;
   unsigned long j_len ;
   unsigned long j_len_alloc ;
   atomic_t j_wcount ;
   unsigned long j_bcount ;
   unsigned long j_first_unflushed_offset ;
   unsigned long j_last_flush_trans_id ;
   struct buffer_head *j_header_bh ;
 
 
 
 
   struct reiserfs_page_list *j_flush_pages ;
   time_t j_trans_start_time ;
   wait_queue_head_t j_wait ;
   atomic_t j_wlock ;
   wait_queue_head_t j_join_wait ;
   atomic_t j_jlock ;
   int j_journal_list_index ;
   int j_list_bitmap_index ;
   int j_must_wait ;
   int j_next_full_flush ;
   int j_next_async_flush ;
 
   int j_cnode_used ;
   int j_cnode_free ;
 
   struct reiserfs_journal_cnode *j_cnode_free_list ;
   struct reiserfs_journal_cnode *j_cnode_free_orig ;
 
   int j_free_bitmap_nodes ;
   int j_used_bitmap_nodes ;
   struct list_head j_bitmap_nodes ;
   struct inode j_dummy_inode ;
   struct reiserfs_list_bitmap j_list_bitmap[5] ;
   struct reiserfs_journal_list j_journal_list[64] ;
   struct reiserfs_journal_cnode *j_hash_table[8192] ;
   struct reiserfs_journal_cnode *j_list_hash_table[8192] ;
 
   struct list_head j_prealloc_list;
 };
 
 
 
 
 typedef __u32 (*hashf_t) (const signed char *, int);
 
 struct proc_dir_entry;
 # 381 "/data1/src/linux/include/linux/reiserfs_fs_sb.h"
 typedef struct reiserfs_proc_info_data
 {} reiserfs_proc_info_data_t;
 
 
 
 struct reiserfs_sb_info
 {
     struct buffer_head * s_sbh;
 
 
     struct reiserfs_super_block * s_rs;
     struct buffer_head ** s_ap_bitmap;
     struct reiserfs_journal *s_journal ;
     unsigned short s_mount_state;
 
 
     void (*end_io_handler)(struct buffer_head *, int);
     hashf_t s_hash_function;
 
 
     unsigned long s_mount_opt;
 
 
 
 
     wait_queue_head_t s_wait;
 
     atomic_t s_generation_counter;
 
 
 
     int s_kmallocs;
     int s_disk_reads;
     int s_disk_writes;
     int s_fix_nodes;
     int s_do_balance;
     int s_unneeded_left_neighbor;
     int s_good_search_by_key_reada;
     int s_bmaps;
     int s_bmaps_without_search;
     int s_direct2indirect;
     int s_indirect2direct;
     reiserfs_proc_info_data_t s_proc_info_data;
     struct proc_dir_entry *procdir;
 };
 # 480 "/data1/src/linux/include/linux/reiserfs_fs_sb.h"
 void reiserfs_file_buffer (struct buffer_head * bh, int list);
 int reiserfs_is_super(struct super_block *s) ;
 int journal_mark_dirty(struct reiserfs_transaction_handle *, struct super_block *, struct buffer_head *bh) ;
 int flush_old_commits(struct super_block *s, int) ;
 int show_reiserfs_locks(void) ;
 int reiserfs_resize(struct super_block *, unsigned long) ;
 # 685 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/bfs_fs_sb.h" 1
 # 12 "/data1/src/linux/include/linux/bfs_fs_sb.h"
 struct bfs_sb_info {
         unsigned long si_blocks;
         unsigned long si_freeb;
         unsigned long si_freei;
         unsigned long si_lf_ioff;
         unsigned long si_lf_sblk;
         unsigned long si_lf_eblk;
         unsigned long si_lasti;
         char * si_imap;
         struct buffer_head * si_sbh;
         struct bfs_super_block * si_bfs_sb;
 };
 # 686 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/udf_fs_sb.h" 1
 # 21 "/data1/src/linux/include/linux/udf_fs_sb.h"
 #pragma pack(1)
 # 30 "/data1/src/linux/include/linux/udf_fs_sb.h"
 struct udf_sparing_data
 {
         __u16 s_packet_len;
         struct buffer_head *s_spar_map[4];
 };
 
 struct udf_virtual_data
 {
         __u32 s_num_entries;
         __u16 s_start_offset;
 };
 
 struct udf_bitmap
 {
         __u32 s_extLength;
         __u32 s_extPosition;
         __u16 s_nr_groups;
         struct buffer_head **s_block_bitmap;
 };
 
 struct udf_part_map
 {
         union
         {
                 struct udf_bitmap *s_bitmap;
                 struct inode *s_table;
         } s_uspace;
         union
         {
                 struct udf_bitmap *s_bitmap;
                 struct inode *s_table;
         } s_fspace;
         __u32 s_partition_root;
         __u32 s_partition_len;
         __u16 s_partition_type;
         __u16 s_partition_num;
         union
         {
                 struct udf_sparing_data s_sparing;
                 struct udf_virtual_data s_virtual;
         } s_type_specific;
         __u32 (*s_partition_func)(struct super_block *, __u32, __u16, __u32);
         __u16 s_volumeseqnum;
         __u16 s_partition_flags;
 };
 
 #pragma pack()
 
 struct udf_sb_info
 {
         struct udf_part_map *s_partmaps;
         __u8 s_volident[32];
 
 
         __u16 s_partitions;
         __u16 s_partition;
 
 
         __s32 s_session;
         __u32 s_anchor[4];
         __u32 s_lastblock;
 
         struct buffer_head *s_lvidbh;
 
 
         mode_t s_umask;
         gid_t s_gid;
         uid_t s_uid;
 
 
         time_t s_recordtime;
 
 
         __u16 s_serialnum;
 
 
         __u16 s_udfrev;
 
 
         __u32 s_flags;
 
 
         struct nls_table *s_nls_map;
 
 
         struct inode *s_vat;
 };
 # 687 "/data1/src/linux/include/linux/fs.h" 2
 # 1 "/data1/src/linux/include/linux/ncp_fs_sb.h" 1
 # 12 "/data1/src/linux/include/linux/ncp_fs_sb.h"
 # 1 "/data1/src/linux/include/linux/ncp_mount.h" 1
 # 12 "/data1/src/linux/include/linux/ncp_mount.h"
 # 1 "/data1/src/linux/include/linux/ncp.h" 1
 # 22 "/data1/src/linux/include/linux/ncp.h"
 struct ncp_request_header {
         __u16 type __attribute__((packed));
         __u8 sequence __attribute__((packed));
         __u8 conn_low __attribute__((packed));
         __u8 task __attribute__((packed));
         __u8 conn_high __attribute__((packed));
         __u8 function __attribute__((packed));
         __u8 data[0] __attribute__((packed));
 };
 
 
 
 
 struct ncp_reply_header {
         __u16 type __attribute__((packed));
         __u8 sequence __attribute__((packed));
         __u8 conn_low __attribute__((packed));
         __u8 task __attribute__((packed));
         __u8 conn_high __attribute__((packed));
         __u8 completion_code __attribute__((packed));
         __u8 connection_state __attribute__((packed));
         __u8 data[0] __attribute__((packed));
 };
 
 
 
 struct ncp_volume_info {
         __u32 total_blocks;
         __u32 free_blocks;
         __u32 purgeable_blocks;
         __u32 not_yet_purgeable_blocks;
         __u32 total_dir_entries;
         __u32 available_dir_entries;
         __u8 sectors_per_block;
         char volume_name[(16) + 1];
 };
 # 112 "/data1/src/linux/include/linux/ncp.h"
 struct nw_info_struct {
         __u32 spaceAlloc __attribute__((packed));
         __u32 attributes __attribute__((packed));
         __u16 flags __attribute__((packed));
         __u32 dataStreamSize __attribute__((packed));
         __u32 totalStreamSize __attribute__((packed));
         __u16 numberOfStreams __attribute__((packed));
         __u16 creationTime __attribute__((packed));
         __u16 creationDate __attribute__((packed));
         __u32 creatorID __attribute__((packed));
         __u16 modifyTime __attribute__((packed));
         __u16 modifyDate __attribute__((packed));
         __u32 modifierID __attribute__((packed));
         __u16 lastAccessDate __attribute__((packed));
         __u16 archiveTime __attribute__((packed));
         __u16 archiveDate __attribute__((packed));
         __u32 archiverID __attribute__((packed));
         __u16 inheritedRightsMask __attribute__((packed));
         __u32 dirEntNum __attribute__((packed));
         __u32 DosDirNum __attribute__((packed));
         __u32 volNumber __attribute__((packed));
         __u32 EADataSize __attribute__((packed));
         __u32 EAKeyCount __attribute__((packed));
         __u32 EAKeySize __attribute__((packed));
         __u32 NSCreator __attribute__((packed));
         __u8 nameLen __attribute__((packed));
         __u8 entryName[256] __attribute__((packed));
 };
 # 156 "/data1/src/linux/include/linux/ncp.h"
 struct nw_modify_dos_info {
         __u32 attributes __attribute__((packed));
         __u16 creationDate __attribute__((packed));
         __u16 creationTime __attribute__((packed));
         __u32 creatorID __attribute__((packed));
         __u16 modifyDate __attribute__((packed));
         __u16 modifyTime __attribute__((packed));
         __u32 modifierID __attribute__((packed));
         __u16 archiveDate __attribute__((packed));
         __u16 archiveTime __attribute__((packed));
         __u32 archiverID __attribute__((packed));
         __u16 lastAccessDate __attribute__((packed));
         __u16 inheritanceGrantMask __attribute__((packed));
         __u16 inheritanceRevokeMask __attribute__((packed));
         __u32 maximumSpace __attribute__((packed));
 };
 
 struct nw_search_sequence {
         __u8 volNumber __attribute__((packed));
         __u32 dirBase __attribute__((packed));
         __u32 sequence __attribute__((packed));
 };
 # 13 "/data1/src/linux/include/linux/ncp_mount.h" 2
 # 25 "/data1/src/linux/include/linux/ncp_mount.h"
 struct ncp_mount_data {
         int version;
         unsigned int ncp_fd;
         __kernel_uid_t mounted_uid;
         __kernel_pid_t wdog_pid;
 
         unsigned char mounted_vol[(16) + 1];
         unsigned int time_out;
 
         unsigned int retry_count;
         unsigned int flags;
 
         __kernel_uid_t uid;
         __kernel_gid_t gid;
         __kernel_mode_t file_mode;
         __kernel_mode_t dir_mode;
 };
 
 
 
 struct ncp_mount_data_v4 {
         int version;
         unsigned long flags;
 
 
         unsigned long mounted_uid;
 
         long wdog_pid;
 
         unsigned int ncp_fd;
         unsigned int time_out;
 
         unsigned int retry_count;
 
 
 
         unsigned long uid;
         unsigned long gid;
 
         unsigned long file_mode;
         unsigned long dir_mode;
 };
 
 
 
 struct ncp_mount_data_kernel {
         unsigned long flags;
         unsigned int int_flags;
 
         __kernel_uid32_t mounted_uid;
         __kernel_pid_t wdog_pid;
         unsigned int ncp_fd;
         unsigned int time_out;
 
         unsigned int retry_count;
         unsigned char mounted_vol[(16) + 1];
         __kernel_uid32_t uid;
         __kernel_gid32_t gid;
         __kernel_mode_t file_mode;
         __kernel_mode_t dir_mode;
 };
 # 13 "/data1/src/linux/include/linux/ncp_fs_sb.h" 2
 
 
 
 
 
 struct ncp_server {
 
         struct ncp_mount_data_kernel m;
 
 
 
         __u8 name_space[(64) + 2];
 
         struct file *ncp_filp;
 
         u8 sequence;
         u8 task;
         u16 connection;
 
         u8 completion;
         u8 conn_status;
 
 
 
         int buffer_size;
 
         int reply_size;
 
         int packet_size;
         unsigned char *packet;
 
 
         int lock;
         struct semaphore sem;
 
         int current_size;
         int has_subfunction;
         int ncp_reply_size;
 
         int root_setuped;
 
 
         int sign_wanted;
         int sign_active;
         char sign_root[8];
         char sign_last[16];
 
 
         struct {
                 int auth_type;
                 size_t object_name_len;
                 void* object_name;
                 int object_type;
         } auth;
 
         struct {
                 size_t len;
                 void* data;
         } priv;
 
 
         struct nls_table *nls_vol;
         struct nls_table *nls_io;
 
 
         int dentry_ttl;
 
 
         unsigned int flags;
 };
 # 92 "/data1/src/linux/include/linux/ncp_fs_sb.h"
 static inline int ncp_conn_valid(struct ncp_server *server)
 {
         return ((server->conn_status & 0x11) == 0);
 }
 
 static inline void ncp_invalidate_conn(struct ncp_server *server)
 {
         server->conn_status |= 0x01;
 }
 # 688 "/data1/src/linux/include/linux/fs.h" 2
 
 # 1 "/data1/src/linux/include/linux/jffs2_fs_sb.h" 1
 
 
 
 
 
 
 
 # 1 "/data1/src/linux/include/linux/completion.h" 1
 # 13 "/data1/src/linux/include/linux/completion.h"
 struct completion {
         unsigned int done;
         wait_queue_head_t wait;
 };
 
 
 
 
 
 
 
 static inline void init_completion(struct completion *x)
 {
         x->done = 0;
         init_waitqueue_head(&x->wait);
 }
 
 extern void wait_for_completion(struct completion *);
 extern void complete(struct completion *);
 # 9 "/data1/src/linux/include/linux/jffs2_fs_sb.h" 2
 # 20 "/data1/src/linux/include/linux/jffs2_fs_sb.h"
 struct jffs2_sb_info {
         struct mtd_info *mtd;
 
         __u32 highest_ino;
         unsigned int flags;
         spinlock_t nodelist_lock;
 
 
         struct task_struct *gc_task;
         struct semaphore gc_thread_start;
         struct completion gc_thread_exit;
 
 
 
         struct semaphore alloc_sem;
 
 
 
 
         __u32 flash_size;
         __u32 used_size;
         __u32 dirty_size;
         __u32 free_size;
         __u32 erasing_size;
         __u32 bad_size;
         __u32 sector_size;
 
 
 
         __u32 nr_free_blocks;
         __u32 nr_erasing_blocks;
 
         __u32 nr_blocks;
         struct jffs2_eraseblock *blocks;
 
         struct jffs2_eraseblock *nextblock;
 
         struct jffs2_eraseblock *gcblock;
 
         struct list_head clean_list;
         struct list_head dirty_list;
         struct list_head erasing_list;
         struct list_head erase_pending_list;
         struct list_head erase_complete_list;
         struct list_head free_list;
         struct list_head bad_list;
         struct list_head bad_used_list;
 
         spinlock_t erase_completion_lock;
 
         wait_queue_head_t erase_wait;
         struct jffs2_inode_cache *inocache_list[1];
         spinlock_t inocache_lock;
 };
 # 690 "/data1/src/linux/include/linux/fs.h" 2
 
 extern struct list_head super_blocks;
 extern spinlock_t sb_lock;
 
 
 
 struct super_block {
         struct list_head s_list;
         kdev_t s_dev;
         unsigned long s_blocksize;
         unsigned char s_blocksize_bits;
         unsigned char s_dirt;
         unsigned long long s_maxbytes;
         struct file_system_type *s_type;
         struct super_operations *s_op;
         struct dquot_operations *dq_op;
         unsigned long s_flags;
         unsigned long s_magic;
         struct dentry *s_root;
         struct rw_semaphore s_umount;
         struct semaphore s_lock;
         int s_count;
         atomic_t s_active;
 
         struct list_head s_dirty;
         struct list_head s_locked_inodes;
         struct list_head s_files;
 
         struct block_device *s_bdev;
         struct list_head s_instances;
         struct quota_mount_options s_dquot;
 
         char s_id[32];
 
         union {
                 struct minix_sb_info minix_sb;
                 struct ext2_sb_info ext2_sb;
                 struct ext3_sb_info ext3_sb;
                 struct hpfs_sb_info hpfs_sb;
                 struct ntfs_sb_info ntfs_sb;
                 struct msdos_sb_info msdos_sb;
                 struct isofs_sb_info isofs_sb;
                 struct nfs_sb_info nfs_sb;
                 struct sysv_sb_info sysv_sb;
                 struct affs_sb_info affs_sb;
                 struct ufs_sb_info ufs_sb;
                 struct efs_sb_info efs_sb;
                 struct shmem_sb_info shmem_sb;
                 struct romfs_sb_info romfs_sb;
                 struct smb_sb_info smbfs_sb;
                 struct hfs_sb_info hfs_sb;
                 struct adfs_sb_info adfs_sb;
                 struct qnx4_sb_info qnx4_sb;
                 struct reiserfs_sb_info reiserfs_sb;
                 struct bfs_sb_info bfs_sb;
                 struct udf_sb_info udf_sb;
                 struct ncp_server ncpfs_sb;
                 struct jffs2_sb_info jffs2_sb;
                 struct cramfs_sb_info cramfs_sb;
                 void *generic_sbp;
         } u;
 
 
 
 
         struct semaphore s_vfs_rename_sem;
 # 764 "/data1/src/linux/include/linux/fs.h"
         struct semaphore s_nfsd_free_path_sem;
 };
 
 
 
 
 extern int vfs_create(struct inode *, struct dentry *, int);
 extern int vfs_mkdir(struct inode *, struct dentry *, int);
 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
 extern int vfs_symlink(struct inode *, struct dentry *, const char *);
 extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
 extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 # 798 "/data1/src/linux/include/linux/fs.h"
 typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
 
 struct block_device_operations {
         int (*open) (struct inode *, struct file *);
         int (*release) (struct inode *, struct file *);
         int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
         int (*check_media_change) (kdev_t);
         int (*revalidate) (kdev_t);
         struct module *owner;
 };
 
 
 
 
 
 
 struct file_operations {
         struct module *owner;
         loff_t (*llseek) (struct file *, loff_t, int);
         ssize_t (*read) (struct file *, char *, size_t, loff_t *);
         ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
         int (*readdir) (struct file *, void *, filldir_t);
         unsigned int (*poll) (struct file *, struct poll_table_struct *);
         int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
         int (*mmap) (struct file *, struct vm_area_struct *);
         int (*open) (struct inode *, struct file *);
         int (*flush) (struct file *);
         int (*release) (struct inode *, struct file *);
         int (*fsync) (struct file *, struct dentry *, int datasync);
         int (*fasync) (int, struct file *, int);
         int (*lock) (struct file *, int, struct file_lock *);
         ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
         ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 };
 
 struct inode_operations {
         int (*create) (struct inode *,struct dentry *,int);
         struct dentry * (*lookup) (struct inode *,struct dentry *);
         int (*link) (struct dentry *,struct inode *,struct dentry *);
         int (*unlink) (struct inode *,struct dentry *);
         int (*symlink) (struct inode *,struct dentry *,const char *);
         int (*mkdir) (struct inode *,struct dentry *,int);
         int (*rmdir) (struct inode *,struct dentry *);
         int (*mknod) (struct inode *,struct dentry *,int,int);
         int (*rename) (struct inode *, struct dentry *,
                         struct inode *, struct dentry *);
         int (*readlink) (struct dentry *, char *,int);
         int (*follow_link) (struct dentry *, struct nameidata *);
         void (*truncate) (struct inode *);
         int (*permission) (struct inode *, int);
         int (*revalidate) (struct dentry *);
         int (*setattr) (struct dentry *, struct iattr *);
         int (*getattr) (struct dentry *, struct iattr *);
 };
 
 struct seq_file;
 
 
 
 
 
 struct super_operations {
         void (*read_inode) (struct inode *);
 
 
 
 
 
 
 
         void (*read_inode2) (struct inode *, void *) ;
         void (*dirty_inode) (struct inode *);
         void (*write_inode) (struct inode *, int);
         void (*put_inode) (struct inode *);
         void (*delete_inode) (struct inode *);
         void (*put_super) (struct super_block *);
         void (*write_super) (struct super_block *);
         void (*write_super_lockfs) (struct super_block *);
         void (*unlockfs) (struct super_block *);
         int (*statfs) (struct super_block *, struct statfs *);
         int (*remount_fs) (struct super_block *, int *, char *);
         void (*clear_inode) (struct inode *);
         void (*umount_begin) (struct super_block *);
 # 906 "/data1/src/linux/include/linux/fs.h"
         struct dentry * (*fh_to_dentry)(struct super_block *sb, __u32 *fh, int len, int fhtype, int parent);
         int (*dentry_to_fh)(struct dentry *, __u32 *fh, int *lenp, int need_parent);
         int (*show_options)(struct seq_file *, struct vfsmount *);
 };
 # 921 "/data1/src/linux/include/linux/fs.h"
 extern void __mark_inode_dirty(struct inode *, int);
 static inline void mark_inode_dirty(struct inode *inode)
 {
         __mark_inode_dirty(inode, (1 | 2 | 4));
 }
 
 static inline void mark_inode_dirty_sync(struct inode *inode)
 {
         __mark_inode_dirty(inode, 1);
 }
 
 static inline void mark_inode_dirty_pages(struct inode *inode)
 {
         __mark_inode_dirty(inode, 4);
 }
 
 struct dquot_operations {
         void (*initialize) (struct inode *, short);
         void (*drop) (struct inode *);
         int (*alloc_block) (struct inode *, unsigned long, char);
         int (*alloc_inode) (const struct inode *, unsigned long);
         void (*free_block) (struct inode *, unsigned long);
         void (*free_inode) (const struct inode *, unsigned long);
         int (*transfer) (struct inode *, struct iattr *);
 };
 
 struct file_system_type {
         const char *name;
         int fs_flags;
         struct super_block *(*read_super) (struct super_block *, void *, int);
         struct module *owner;
         struct file_system_type * next;
         struct list_head fs_supers;
 };
 # 979 "/data1/src/linux/include/linux/fs.h"
 extern int register_filesystem(struct file_system_type *);
 extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount(struct file_system_type *);
 extern int may_umount(struct vfsmount *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
 extern void umount_tree(struct vfsmount *);
 
 
 
 extern int vfs_statfs(struct super_block *, struct statfs *);
 # 998 "/data1/src/linux/include/linux/fs.h"
 extern int locks_mandatory_locked(struct inode *);
 extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
 # 1008 "/data1/src/linux/include/linux/fs.h"
 static inline int locks_verify_locked(struct inode *inode)
 {
         if ((((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
                 return locks_mandatory_locked(inode);
         return 0;
 }
 
 static inline int locks_verify_area(int read_write, struct inode *inode,
                                     struct file *filp, loff_t offset,
                                     size_t count)
 {
         if (inode->i_flock && (((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
                 return locks_mandatory_area(read_write, inode, filp, offset, count);
         return 0;
 }
 
 static inline int locks_verify_truncate(struct inode *inode,
                                     struct file *filp,
                                     loff_t size)
 {
         if (inode->i_flock && (((inode)->i_sb->s_flags & (64)) && ((inode)->i_mode & (0002000 | 00010)) == 0002000))
                 return locks_mandatory_area(
                         2, inode, filp,
                         size < inode->i_size ? size : inode->i_size,
                         (size < inode->i_size ? inode->i_size - size
                          : size - inode->i_size)
                 );
         return 0;
 }
 
 static inline int get_lease(struct inode *inode, unsigned int mode)
 {
         if (inode->i_flock && (inode->i_flock->fl_flags & 32))
                 return __get_lease(inode, mode);
         return 0;
 }
 
 
 
  __attribute__((syscall_linkage)) long sys_open(const char *, int, int);
  __attribute__((syscall_linkage)) long sys_close(unsigned int);
 extern int do_truncate(struct dentry *, loff_t start);
 
 extern struct file *filp_open(const char *, int, int);
 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
 extern int filp_close(struct file *, fl_owner_t id);
 extern char * getname(const char *);
 
 
 extern void vfs_caches_init(unsigned long);
 
 
 
 
 enum {BDEV_FILE, BDEV_SWAP, BDEV_FS, BDEV_RAW};
 extern int register_blkdev(unsigned int, const char *, struct block_device_operations *);
 extern int unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern int bd_acquire(struct inode *inode);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern struct char_device *cdget(dev_t);
 extern void cdput(struct char_device *);
 extern int blkdev_open(struct inode *, struct file *);
 extern int blkdev_close(struct inode *, struct file *);
 extern struct file_operations def_blk_fops;
 extern struct address_space_operations def_blk_aops;
 extern struct file_operations def_fifo_fops;
 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
 extern int blkdev_get(struct block_device *, mode_t, unsigned, int);
 extern int blkdev_put(struct block_device *, int);
 
 
 extern const struct block_device_operations *get_blkfops(unsigned int);
 extern int register_chrdev(unsigned int, const char *, struct file_operations *);
 extern int unregister_chrdev(unsigned int, const char *);
 extern int chrdev_open(struct inode *, struct file *);
 extern const char * bdevname(kdev_t);
 extern const char * cdevname(kdev_t);
 extern const char * kdevname(kdev_t);
 extern void init_special_inode(struct inode *, umode_t, int);
 
 
 extern void make_bad_inode(struct inode *);
 extern int is_bad_inode(struct inode *);
 
 extern struct file_operations read_fifo_fops;
 extern struct file_operations write_fifo_fops;
 extern struct file_operations rdwr_fifo_fops;
 extern struct file_operations read_pipe_fops;
 extern struct file_operations write_pipe_fops;
 extern struct file_operations rdwr_pipe_fops;
 
 extern int fs_may_remount_ro(struct super_block *);
 
 extern int try_to_free_buffers(struct page *, unsigned int);
 extern void refile_buffer(struct buffer_head * buf);
 extern void create_empty_buffers(struct page *, unsigned long);
 extern void end_buffer_io_sync(struct buffer_head *bh, int uptodate);
 
 
 extern void set_buffer_async_io(struct buffer_head *bh) ;
 
 
 
 
 
 
 static inline void get_bh(struct buffer_head * bh)
 {
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&(bh)->b_count)))->counter)) *_v = (&(((&(bh)->b_coun t)))->counter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0 =[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tm p) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switc!
 h (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memor y"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: _ _asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ (" fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add!
 (); } }); break; case 4: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_ tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8)  : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&(bh)->b_count)))->counter))) { ca se 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __!
 bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&(bh)->b_count)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&(bh)->b_count))));
 }
 
 static inline void put_bh(struct buffer_head *bh)
 {
         __asm__ __volatile__("": : :"memory");
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&bh->b_count)))->counter)) *_v = (&(((&bh->b_count))) ->counter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[% 1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) :  "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (si!
 zeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); br eak; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __ volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.r el %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); b!
 reak; case 4: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v ), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); br eak; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&bh->b_count)))->counter))) { case 4: __asm__ __v olatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64!
 _fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&bh->b_count)))->counter)) (_tmp + (-((1)))); }) : ia64_atomic_sub((1), ((&bh->b_count))));
 }
 
 
 
 
 static inline void mark_buffer_uptodate(struct buffer_head * bh, int on)
 {
         if (on)
                 set_bit(BH_Uptodate, &bh->b_state);
         else
                 clear_bit(BH_Uptodate, &bh->b_state);
 }
 
 
 
 static inline void __mark_buffer_clean(struct buffer_head *bh)
 {
         refile_buffer(bh);
 }
 
 static inline void mark_buffer_clean(struct buffer_head * bh)
 {
         if (test_and_clear_bit(BH_Dirty, &(bh)->b_state))
                 __mark_buffer_clean(bh);
 }
 
 extern void __mark_dirty(struct buffer_head *bh);
 extern void __mark_buffer_dirty(struct buffer_head *bh);
 extern void mark_buffer_dirty(struct buffer_head *bh);
 extern void buffer_insert_inode_data_queue(struct buffer_head *, struct inode *);
 
 
 
 static inline void mark_buffer_async(struct buffer_head * bh, int on)
 {
         if (on)
                 set_bit(BH_Async, &bh->b_state);
         else
                 clear_bit(BH_Async, &bh->b_state);
 }
 
 
 
 
 
 
 
 static inline void buffer_IO_error(struct buffer_head * bh)
 {
         mark_buffer_clean(bh);
 
 
 
 
 
 
         bh->b_end_io(bh, test_bit(BH_Uptodate, &bh->b_state));
 }
 # 1194 "/data1/src/linux/include/linux/fs.h"
 extern void buffer_insert_inode_queue(struct buffer_head *, struct inode *);
 static inline void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
 {
         mark_buffer_dirty(bh);
         buffer_insert_inode_queue(bh, inode);
 }
 
 extern void set_buffer_flushtime(struct buffer_head *);
 extern void balance_dirty(void);
 extern int check_disk_change(kdev_t);
 extern int invalidate_inodes(struct super_block *);
 extern int invalidate_device(kdev_t, int);
 extern void invalidate_inode_pages(struct inode *);
 extern void invalidate_inode_pages2(struct address_space *);
 extern void invalidate_inode_buffers(struct inode *);
 
 
 extern void invalidate_bdev(struct block_device *, int);
 extern void __invalidate_buffers(kdev_t dev, int);
 extern void sync_inodes(kdev_t);
 extern void sync_unlocked_inodes(void);
 extern void write_inode_now(struct inode *, int);
 extern int sync_buffers(kdev_t, int);
 extern void sync_dev(kdev_t);
 extern int fsync_dev(kdev_t);
 extern int fsync_super(struct super_block *);
 extern int fsync_no_super(struct block_device *);
 extern void sync_inodes_sb(struct super_block *);
 extern int osync_inode_buffers(struct inode *);
 extern int osync_inode_data_buffers(struct inode *);
 extern int fsync_inode_buffers(struct inode *);
 extern int fsync_inode_data_buffers(struct inode *);
 extern int inode_has_buffers(struct inode *);
 extern void filemap_fdatasync(struct address_space *);
 extern void filemap_fdatawait(struct address_space *);
 extern void sync_supers(kdev_t);
 extern int bmap(struct inode *, int);
 extern int notify_change(struct dentry *, struct iattr *);
 extern int permission(struct inode *, int);
 extern int vfs_permission(struct inode *, int);
 extern int get_write_access(struct inode *);
 extern int deny_write_access(struct file *);
 static inline void put_write_access(struct inode * inode)
 {
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&inode->i_writecount)))->counter)) *_v = (&(((&inode- >i_writecount)))->counter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile __ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4 .rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }!
 ); break; case -4: ({ switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"( _tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v) , "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&inode->i_writecount)))- >counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); brea!
 k; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm_ _ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ (" fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ( { switch (sizeof(*(&(((&inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" !
 : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&inode->i_writecount)))->counter)) (_tmp + (-((1)))); }) :  ia64_atomic_sub((1), ((&inode->i_writecount))));
 }
 static inline void allow_write_access(struct file *file)
 {
         if (file)
                 ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&file->f_dentry->d_inode->i_writecount)))->co unter)) *_v = (&(((&file->f_dentry->d_inode->i_writecount)))->counter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&file->f_dentry->d_inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_ v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&file->f_dentry->d_ inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), !
 "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&(((&file->f_dentry->d_inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v ), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&file->f_dentry->d_ino de->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; de fault: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&file->f_dentry->d_inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "!
 i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&file->f_dentry->d_inode->i_w ritecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __ bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&file->f_dentry->d_inode->i_writecount)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __ asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&file->f_dentry->d_inode->i_writecoun!
 t)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_si ze_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&file->f_dentry->d_inode->i_writecount)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&file->f_dentry->d_inode->i_wri tecount))));
 }
 extern int do_pipe(int *);
 
 extern int open_namei(const char *, int, int, struct nameidata *);
 
 extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
 extern struct file * open_exec(const char *);
 
 
 extern int is_subdir(struct dentry *, struct dentry *);
 extern ino_t find_inode_number(struct dentry *, struct qstr *);
 # 1264 "/data1/src/linux/include/linux/fs.h"
 static inline void *ERR_PTR(long error)
 {
         return (void *) error;
 }
 
 static inline long PTR_ERR(const void *ptr)
 {
         return (long) ptr;
 }
 
 static inline long IS_ERR(const void *ptr)
 {
         return (unsigned long)ptr > (unsigned long)-1000L;
 }
 # 1295 "/data1/src/linux/include/linux/fs.h"
 enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 # 1306 "/data1/src/linux/include/linux/fs.h"
 typedef struct {
         size_t written;
         size_t count;
         char * buf;
         int error;
 } read_descriptor_t;
 
 typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
 
 
 extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
 
 extern int __user_walk(const char *, unsigned, struct nameidata *);
 extern int path_init(const char *, unsigned, struct nameidata *);
 extern int path_walk(const char *, struct nameidata *);
 extern int link_path_walk(const char *, struct nameidata *);
 extern void path_release(struct nameidata *);
 extern int follow_down(struct vfsmount **, struct dentry **);
 extern int follow_up(struct vfsmount **, struct dentry **);
 extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
 extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
 
 
 
 extern void iput(struct inode *);
 extern void force_delete(struct inode *);
 extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 
 typedef int (*find_inode_t)(struct inode *, unsigned long, void *);
 extern struct inode * iget4(struct super_block *, unsigned long, find_inode_t, void *);
 static inline struct inode *iget(struct super_block *sb, unsigned long ino)
 {
         return iget4(sb, ino, ((void *)0), ((void *)0));
 }
 
 extern void clear_inode(struct inode *);
 extern struct inode * get_empty_inode(void);
 
 static inline struct inode * new_inode(struct super_block *sb)
 {
         struct inode *inode = get_empty_inode();
         if (inode) {
                 inode->i_sb = sb;
                 inode->i_dev = sb->s_dev;
                 inode->i_blkbits = sb->s_blocksize_bits;
         }
         return inode;
 }
 extern void remove_suid(struct inode *inode);
 
 extern void insert_inode_hash(struct inode *);
 extern void remove_inode_hash(struct inode *);
 extern struct file * get_empty_filp(void);
 extern void file_move(struct file *f, struct list_head *list);
 extern struct buffer_head * __get_hash_table(struct block_device *, sector_t, int);
 static inline struct buffer_head * get_hash_table(kdev_t dev, sector_t block, int size)
 {
         struct block_device *bdev;
         struct buffer_head *bh;
         bdev = bdget(kdev_t_to_nr(dev));
         if (!bdev) {
                 printk("No block device for %s\n", bdevname(dev));
                 do { printk("kernel BUG at %s:%d!\n", "/data1/src/linux/include/linux/fs.h", 1369); *(int *)0=0; } while (0);
         }
         bh = __get_hash_table(bdev, block, size);
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&bdev->bd_count)))->counter)) *_v = (&(((&bdev->bd_co unt)))->counter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8. rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : " =r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: (!
 { switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4)  : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break;  case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __vol atile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fet!
 ch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],% 2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"( _v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&bdev->bd_count)))->co unter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break!
 ; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&bdev->bd_count)))->counter)) (_tmp + (-((1)))); }) : ia64_atomic_sub((1), ((&bdev->bd_count))));
         return bh;
 }
 extern struct buffer_head * __getblk(struct block_device *, sector_t, int);
 static inline struct buffer_head * getblk(kdev_t dev, sector_t block, int size)
 {
         struct block_device *bdev;
         struct buffer_head *bh;
         bdev = bdget(kdev_t_to_nr(dev));
         if (!bdev) {
                 printk("No block device for %s\n", bdevname(dev));
                 do { printk("kernel BUG at %s:%d!\n", "/data1/src/linux/include/linux/fs.h", 1383); *(int *)0=0; } while (0);
         }
         bh = __getblk(bdev, block, size);
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&bdev->bd_count)))->counter)) *_v = (&(((&bdev->bd_co unt)))->counter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8. rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : " =r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: (!
 { switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4)  : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break;  case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __vol atile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fet!
 ch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],% 2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"( _v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&bdev->bd_count)))->co unter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break!
 ; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&bdev->bd_count)))->counter)) (_tmp + (-((1)))); }) : ia64_atomic_sub((1), ((&bdev->bd_count))));
         return bh;
 }
 extern void ll_rw_block(int, int, struct buffer_head * bh[]);
 extern int submit_bh(int, struct buffer_head *);
 struct bio;
 extern int submit_bio(int, struct bio *);
 extern int is_read_only(kdev_t);
 extern void __brelse(struct buffer_head *);
 static inline void brelse(struct buffer_head *buf)
 {
         if (buf)
                 __brelse(buf);
 }
 extern void __bforget(struct buffer_head *);
 static inline void bforget(struct buffer_head *buf)
 {
         if (buf)
                 __bforget(buf);
 }
 extern int set_blocksize(kdev_t, int);
 extern int sb_set_blocksize(struct super_block *, int);
 extern int sb_min_blocksize(struct super_block *, int);
 extern struct buffer_head * __bread(struct block_device *, int, int);
 static inline struct buffer_head * bread(kdev_t dev, int block, int size)
 {
         struct block_device *bdev;
         struct buffer_head *bh;
         bdev = bdget(kdev_t_to_nr(dev));
         if (!bdev) {
                 printk("No block device for %s\n", bdevname(dev));
                 do { printk("kernel BUG at %s:%d!\n", "/data1/src/linux/include/linux/fs.h", 1417); *(int *)0=0; } while (0);
         }
         bh = __bread(bdev, block, size);
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&bdev->bd_count)))->counter)) *_v = (&(((&bdev->bd_co unt)))->counter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8. rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : " =r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: (!
 { switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4)  : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break;  case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __vol atile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fet!
 ch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],% 2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&bdev->bd_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"( _v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&bdev->bd_count)))->co unter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break!
 ; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&bdev->bd_count)))->counter)) (_tmp + (-((1)))); }) : ia64_atomic_sub((1), ((&bdev->bd_count))));
         return bh;
 }
 static inline struct buffer_head * sb_bread(struct super_block *sb, int block)
 {
         return __bread(sb->s_bdev, block, sb->s_blocksize);
 }
 static inline struct buffer_head * sb_getblk(struct super_block *sb, int block)
 {
         return __getblk(sb->s_bdev, block, sb->s_blocksize);
 }
 static inline struct buffer_head * sb_get_hash_table(struct super_block *sb, int block)
 {
         return __get_hash_table(sb->s_bdev, block, sb->s_blocksize);
 }
 static inline void map_bh(struct buffer_head *bh, struct super_block *sb, int block)
 {
         bh->b_state |= 1 << BH_Mapped;
         bh->b_bdev = sb->s_bdev;
         bh->b_dev = sb->s_dev;
         bh->b_blocknr = block;
 }
 extern void wakeup_bdflush(void);
 extern void put_unused_buffer_head(struct buffer_head * bh);
 extern struct buffer_head * get_unused_buffer_head(int async);
 
 extern int brw_page(int, struct page *, struct block_device *, sector_t [], int);
 
 typedef int (get_block_t)(struct inode*,sector_t,struct buffer_head*,int);
 
 
 extern int try_to_release_page(struct page * page, int gfp_mask);
 extern int discard_bh_page(struct page *, unsigned long, int);
 
 
 extern int block_symlink(struct inode *, const char *, int);
 extern int block_write_full_page(struct page*, get_block_t*);
 extern int block_read_full_page(struct page*, get_block_t*);
 extern int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
 extern int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
                                 unsigned long *);
 extern int block_commit_write(struct page *page, unsigned from, unsigned to);
 extern int block_sync_page(struct page *);
 
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
 int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
 int block_truncate_page(struct address_space *, loff_t, get_block_t *);
 extern int generic_direct_IO(int, struct inode *, struct kiobuf *, unsigned long, int, get_block_t *);
 
 extern int waitfor_one_page(struct page*);
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
 extern ssize_t generic_file_read(struct file *, char *, size_t, loff_t *);
 extern ssize_t generic_file_write(struct file *, const char *, size_t, loff_t *);
 extern void do_generic_file_read(struct file *, loff_t *, read_descriptor_t *, read_actor_t);
 extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
 extern ssize_t generic_read_dir(struct file *, char *, size_t, loff_t *);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 
 extern struct file_operations generic_ro_fops;
 
 extern int vfs_readlink(struct dentry *, char *, int, const char *);
 extern int vfs_follow_link(struct nameidata *, const char *);
 extern int page_readlink(struct dentry *, char *, int);
 extern int page_follow_link(struct dentry *, struct nameidata *);
 extern struct inode_operations page_symlink_inode_operations;
 
 extern int vfs_readdir(struct file *, filldir_t, void *);
 extern int dcache_readdir(struct file *, void *, filldir_t);
 
 extern struct file_system_type *get_fs_type(const char *name);
 extern struct super_block *get_super(kdev_t);
 extern void drop_super(struct super_block *sb);
 static inline int is_mounted(kdev_t dev)
 {
         struct super_block *sb = get_super(dev);
         if (sb) {
                 drop_super(sb);
                 return 1;
         }
         return 0;
 }
 unsigned long generate_cluster(kdev_t, int b[], int);
 unsigned long generate_cluster_swab32(kdev_t, int b[], int);
 extern kdev_t ROOT_DEV;
 extern char root_device_name[];
 
 
 extern void show_buffers(void);
 
 
 
 
 
 extern ssize_t char_read(struct file *, char *, size_t, loff_t *);
 extern ssize_t block_read(struct file *, char *, size_t, loff_t *);
 extern int read_ahead[];
 
 extern ssize_t char_write(struct file *, const char *, size_t, loff_t *);
 extern ssize_t block_write(struct file *, const char *, size_t, loff_t *);
 
 extern int file_fsync(struct file *, struct dentry *, int);
 extern int generic_buffer_fdatasync(struct inode *inode, unsigned long start_idx, unsigned long end_idx);
 extern int generic_osync_inode(struct inode *, int);
 
 
 
 
 extern int inode_change_ok(struct inode *, struct iattr *);
 extern int inode_setattr(struct inode *, struct iattr *);
 # 1551 "/data1/src/linux/include/linux/fs.h"
 static inline struct dentry *lock_parent(struct dentry *dentry)
 {
         struct dentry *dir = dget(dentry->d_parent);
 
         down(&dir->d_inode->i_sem);
         return dir;
 }
 
 static inline struct dentry *get_parent(struct dentry *dentry)
 {
         return dget(dentry->d_parent);
 }
 
 static inline void unlock_dir(struct dentry *dir)
 {
         up(&dir->d_inode->i_sem);
         dput(dir);
 }
 
 
 
 
 
 static inline void double_down(struct semaphore *s1, struct semaphore *s2)
 {
         if (s1 != s2) {
                 if ((unsigned long) s1 < (unsigned long) s2) {
                         struct semaphore *tmp = s2;
                         s2 = s1; s1 = tmp;
                 }
                 down(s1);
         }
         down(s2);
 }
 # 1595 "/data1/src/linux/include/linux/fs.h"
 static inline void triple_down(struct semaphore *s1,
                                struct semaphore *s2,
                                struct semaphore *s3)
 {
         if (s1 != s2) {
                 if ((unsigned long) s1 < (unsigned long) s2) {
                         if ((unsigned long) s1 < (unsigned long) s3) {
                                 struct semaphore *tmp = s3;
                                 s3 = s1; s1 = tmp;
                         }
                         if ((unsigned long) s1 < (unsigned long) s2) {
                                 struct semaphore *tmp = s2;
                                 s2 = s1; s1 = tmp;
                         }
                 } else {
                         if ((unsigned long) s1 < (unsigned long) s3) {
                                 struct semaphore *tmp = s3;
                                 s3 = s1; s1 = tmp;
                         }
                         if ((unsigned long) s2 < (unsigned long) s3) {
                                 struct semaphore *tmp = s3;
                                 s3 = s2; s2 = tmp;
                         }
                 }
                 down(s1);
         } else if ((unsigned long) s2 < (unsigned long) s3) {
                 struct semaphore *tmp = s3;
                 s3 = s2; s2 = tmp;
         }
         down(s2);
         down(s3);
 }
 
 static inline void double_up(struct semaphore *s1, struct semaphore *s2)
 {
         up(s1);
         if (s1 != s2)
                 up(s2);
 }
 
 static inline void triple_up(struct semaphore *s1,
                              struct semaphore *s2,
                              struct semaphore *s3)
 {
         up(s1);
         if (s1 != s2)
                 up(s2);
         up(s3);
 }
 
 static inline void double_lock(struct dentry *d1, struct dentry *d2)
 {
         double_down(&d1->d_inode->i_sem, &d2->d_inode->i_sem);
 }
 
 static inline void double_unlock(struct dentry *d1, struct dentry *d2)
 {
         double_up(&d1->d_inode->i_sem,&d2->d_inode->i_sem);
         dput(d1);
         dput(d2);
 }
 # 18 "/data1/src/linux/include/linux/capability.h" 2
 # 32 "/data1/src/linux/include/linux/capability.h"
 typedef struct __user_cap_header_struct {
         __u32 version;
         int pid;
 } *cap_user_header_t;
 
 typedef struct __user_cap_data_struct {
         __u32 effective;
         __u32 permitted;
         __u32 inheritable;
 } *cap_user_data_t;
 # 55 "/data1/src/linux/include/linux/capability.h"
 typedef __u32 kernel_cap_t;
 # 286 "/data1/src/linux/include/linux/capability.h"
 extern kernel_cap_t cap_bset;
 # 314 "/data1/src/linux/include/linux/capability.h"
 static inline kernel_cap_t cap_combine(kernel_cap_t a, kernel_cap_t b)
 {
      kernel_cap_t dest;
      (dest) = (a) | (b);
      return dest;
 }
 
 static inline kernel_cap_t cap_intersect(kernel_cap_t a, kernel_cap_t b)
 {
      kernel_cap_t dest;
      (dest) = (a) & (b);
      return dest;
 }
 
 static inline kernel_cap_t cap_drop(kernel_cap_t a, kernel_cap_t drop)
 {
      kernel_cap_t dest;
      (dest) = (a) & ~(drop);
      return dest;
 }
 
 static inline kernel_cap_t cap_invert(kernel_cap_t c)
 {
      kernel_cap_t dest;
      (dest) = ~(c);
      return dest;
 }
 # 6 "/data1/src/linux/include/linux/binfmts.h" 2
 # 22 "/data1/src/linux/include/linux/binfmts.h"
 struct linux_binprm{
         char buf[128];
         struct page *page[32];
         unsigned long p;
         int sh_bang;
         struct file * file;
         int e_uid, e_gid;
         kernel_cap_t cap_inheritable, cap_permitted, cap_effective;
         int argc, envc;
         char * filename;
         unsigned long loader, exec;
 };
 
 
 
 
 
 struct linux_binfmt {
         struct linux_binfmt * next;
         struct module *module;
         int (*load_binary)(struct linux_binprm *, struct pt_regs * regs);
         int (*load_shlib)(struct file *);
         int (*core_dump)(long signr, struct pt_regs * regs, struct file * file);
         unsigned long min_coredump;
 };
 
 extern int register_binfmt(struct linux_binfmt *);
 extern int unregister_binfmt(struct linux_binfmt *);
 
 extern int prepare_binprm(struct linux_binprm *);
 extern void remove_arg_zero(struct linux_binprm *);
 extern int search_binary_handler(struct linux_binprm *,struct pt_regs *);
 extern int flush_old_exec(struct linux_binprm * bprm);
 extern int setup_arg_pages(struct linux_binprm * bprm);
 extern int copy_strings(int argc,char ** argv,struct linux_binprm *bprm);
 extern int copy_strings_kernel(int argc,char ** argv,struct linux_binprm *bprm);
 extern void compute_creds(struct linux_binprm *binprm);
 extern int do_coredump(long signr, struct pt_regs * regs);
 extern void set_binfmt(struct linux_binfmt *new);
 # 10 "/data1/src/linux/include/linux/sched.h" 2
 
 
 
 # 1 "/data1/src/linux/include/linux/times.h" 1
 
 
 
 struct tms {
         clock_t tms_utime;
         clock_t tms_stime;
         clock_t tms_cutime;
         clock_t tms_cstime;
 };
 # 14 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/timex.h" 1
 # 152 "/data1/src/linux/include/linux/timex.h"
 # 1 "/data1/src/linux/include/asm/timex.h" 1
 # 13 "/data1/src/linux/include/asm/timex.h"
 typedef unsigned long cycles_t;
 
 static inline cycles_t
 get_cycles (void)
 {
         cycles_t ret;
 
         __asm__ __volatile__ ("mov %0=ar.itc" : "=r"(ret));
         return ret;
 }
 # 153 "/data1/src/linux/include/linux/timex.h" 2
 # 161 "/data1/src/linux/include/linux/timex.h"
 struct timex {
         unsigned int modes;
         long offset;
         long freq;
         long maxerror;
         long esterror;
         int status;
         long constant;
         long precision;
         long tolerance;
 
 
         struct timeval time;
         long tick;
 
         long ppsfreq;
         long jitter;
         int shift;
         long stabil;
         long jitcnt;
         long calcnt;
         long errcnt;
         long stbcnt;
 
         int :32; int :32; int :32; int :32;
         int :32; int :32; int :32; int :32;
         int :32; int :32; int :32; int :32;
 };
 # 253 "/data1/src/linux/include/linux/timex.h"
 extern long tick;
 extern int tickadj;
 
 
 
 
 extern int time_state;
 extern int time_status;
 extern long time_offset;
 extern long time_constant;
 extern long time_tolerance;
 extern long time_precision;
 extern long time_maxerror;
 extern long time_esterror;
 
 extern long time_phase;
 extern long time_freq;
 extern long time_adj;
 extern long time_reftime;
 
 extern long time_adjust;
 
 
 extern long pps_offset;
 extern long pps_jitter;
 extern long pps_freq;
 extern long pps_stabil;
 extern long pps_valid;
 
 
 extern int pps_shift;
 extern long pps_jitcnt;
 extern long pps_calcnt;
 extern long pps_errcnt;
 extern long pps_stbcnt;
 # 15 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/rbtree.h" 1
 # 100 "/data1/src/linux/include/linux/rbtree.h"
 typedef struct rb_node_s
 {
         struct rb_node_s * rb_parent;
         int rb_color;
 
 
         struct rb_node_s * rb_right;
         struct rb_node_s * rb_left;
 }
 rb_node_t;
 
 typedef struct rb_root_s
 {
         struct rb_node_s * rb_node;
 }
 rb_root_t;
 
 
 
 
 
 extern void rb_insert_color(rb_node_t *, rb_root_t *);
 extern void rb_erase(rb_node_t *, rb_root_t *);
 
 static inline void rb_link_node(rb_node_t * node, rb_node_t * parent, rb_node_t ** rb_link)
 {
         node->rb_parent = parent;
         node->rb_color = 0;
         node->rb_left = node->rb_right = ((void *)0);
 
         *rb_link = node;
 }
 # 16 "/data1/src/linux/include/linux/sched.h" 2
 
 
 
 
 
 # 1 "/data1/src/linux/include/asm/mmu.h" 1
 
 
 
 
 typedef unsigned long mm_context_t;
 # 22 "/data1/src/linux/include/linux/sched.h" 2
 
 # 1 "/data1/src/linux/include/linux/smp.h" 1
 # 14 "/data1/src/linux/include/linux/smp.h"
 # 1 "/data1/src/linux/include/asm/smp.h" 1
 # 16 "/data1/src/linux/include/asm/smp.h"
 # 1 "/data1/src/linux/include/linux/init.h" 1
 # 48 "/data1/src/linux/include/linux/init.h"
 typedef int (*initcall_t)(void);
 typedef void (*exitcall_t)(void);
 
 extern initcall_t __initcall_start, __initcall_end;
 # 61 "/data1/src/linux/include/linux/init.h"
 struct kernel_param {
         const char *str;
         int (*setup_func)(char *);
 };
 
 extern struct kernel_param __setup_start, __setup_end;
 # 17 "/data1/src/linux/include/asm/smp.h" 2
 
 
 
 # 1 "/data1/src/linux/include/asm/io.h" 1
 # 37 "/data1/src/linux/include/asm/io.h"
 # 1 "/data1/src/linux/include/asm/machvec.h" 1
 # 17 "/data1/src/linux/include/asm/machvec.h"
 struct pci_dev;
 struct pt_regs;
 struct scatterlist;
 struct irq_desc;
 
 typedef void ia64_mv_setup_t (char **);
 typedef void ia64_mv_cpu_init_t(void);
 typedef void ia64_mv_irq_init_t (void);
 typedef void ia64_mv_pci_fixup_t (int);
 typedef unsigned long ia64_mv_map_nr_t (unsigned long);
 typedef void ia64_mv_mca_init_t (void);
 typedef void ia64_mv_mca_handler_t (void);
 typedef void ia64_mv_cmci_handler_t (int, void *, struct pt_regs *);
 typedef void ia64_mv_log_print_t (void);
 typedef void ia64_mv_send_ipi_t (int, int, int, int);
 typedef void ia64_mv_global_tlb_purge_t (unsigned long, unsigned long, unsigned long);
 typedef struct irq_desc *ia64_mv_irq_desc (unsigned int);
 typedef u8 ia64_mv_irq_to_vector (u8);
 typedef unsigned int ia64_mv_local_vector_to_irq (u8 vector);
 
 
 typedef void ia64_mv_pci_dma_init (void);
 typedef void *ia64_mv_pci_alloc_consistent (struct pci_dev *, size_t, dma_addr_t *);
 typedef void ia64_mv_pci_free_consistent (struct pci_dev *, size_t, void *, dma_addr_t);
 typedef dma_addr_t ia64_mv_pci_map_single (struct pci_dev *, void *, size_t, int);
 typedef void ia64_mv_pci_unmap_single (struct pci_dev *, dma_addr_t, size_t, int);
 typedef int ia64_mv_pci_map_sg (struct pci_dev *, struct scatterlist *, int, int);
 typedef void ia64_mv_pci_unmap_sg (struct pci_dev *, struct scatterlist *, int, int);
 typedef void ia64_mv_pci_dma_sync_single (struct pci_dev *, dma_addr_t, size_t, int);
 typedef void ia64_mv_pci_dma_sync_sg (struct pci_dev *, struct scatterlist *, int, int);
 typedef unsigned long ia64_mv_pci_dma_address (struct scatterlist *);
 # 57 "/data1/src/linux/include/asm/machvec.h"
 typedef unsigned int ia64_mv_inb_t (unsigned long);
 typedef unsigned int ia64_mv_inw_t (unsigned long);
 typedef unsigned int ia64_mv_inl_t (unsigned long);
 typedef void ia64_mv_outb_t (unsigned char, unsigned long);
 typedef void ia64_mv_outw_t (unsigned short, unsigned long);
 typedef void ia64_mv_outl_t (unsigned int, unsigned long);
 typedef void ia64_mv_mmiob_t (void);
 
 extern void machvec_noop (void);
 
 
 
 
 # 1 "/data1/src/linux/include/asm/machvec_dig.h" 1
 
 
 
 extern ia64_mv_setup_t dig_setup;
 extern ia64_mv_irq_init_t dig_irq_init;
 extern ia64_mv_pci_fixup_t iosapic_pci_fixup;
 extern ia64_mv_map_nr_t map_nr_dense;
 # 71 "/data1/src/linux/include/asm/machvec.h" 2
 # 193 "/data1/src/linux/include/asm/machvec.h"
 extern ia64_mv_pci_dma_init swiotlb_init;
 extern ia64_mv_pci_alloc_consistent swiotlb_alloc_consistent;
 extern ia64_mv_pci_free_consistent swiotlb_free_consistent;
 extern ia64_mv_pci_map_single swiotlb_map_single;
 extern ia64_mv_pci_unmap_single swiotlb_unmap_single;
 extern ia64_mv_pci_map_sg swiotlb_map_sg;
 extern ia64_mv_pci_unmap_sg swiotlb_unmap_sg;
 extern ia64_mv_pci_dma_sync_single swiotlb_sync_single;
 extern ia64_mv_pci_dma_sync_sg swiotlb_sync_sg;
 extern ia64_mv_pci_dma_address swiotlb_dma_address;
 # 38 "/data1/src/linux/include/asm/io.h" 2
 
 
 
 
 
 
 static inline unsigned long
 virt_to_phys (volatile void *address)
 {
         return (unsigned long) address - 0xe000000000000000;
 }
 
 static inline void*
 phys_to_virt (unsigned long address)
 {
         return (void *) (address + 0xe000000000000000);
 }
 # 82 "/data1/src/linux/include/asm/io.h"
 static inline void
 __ia64_mmiob (void)
 {
         __asm__ __volatile__ ("mf.a" ::: "memory");
 }
 
 static inline const unsigned long
 __ia64_get_io_port_base (void)
 {
         extern unsigned long ia64_iobase;
 
         return ia64_iobase;
 }
 
 static inline void*
 __ia64_mk_io_addr (unsigned long port)
 {
         const unsigned long io_base = __ia64_get_io_port_base();
         unsigned long addr;
 
         addr = io_base | ((port >> 2) << 12) | (port & 0xfff);
         return (void *) addr;
 }
 # 114 "/data1/src/linux/include/asm/io.h"
 static inline unsigned int
 __ia64_inb (unsigned long port)
 {
         volatile unsigned char *addr = __ia64_mk_io_addr(port);
         unsigned char ret;
 
         ret = *addr;
         __asm__ __volatile__ ("mf.a" ::: "memory");
         return ret;
 }
 
 static inline unsigned int
 __ia64_inw (unsigned long port)
 {
         volatile unsigned short *addr = __ia64_mk_io_addr(port);
         unsigned short ret;
 
         ret = *addr;
         __asm__ __volatile__ ("mf.a" ::: "memory");
         return ret;
 }
 
 static inline unsigned int
 __ia64_inl (unsigned long port)
 {
         volatile unsigned int *addr = __ia64_mk_io_addr(port);
         unsigned int ret;
 
         ret = *addr;
         __asm__ __volatile__ ("mf.a" ::: "memory");
         return ret;
 }
 
 static inline void
 __ia64_outb (unsigned char val, unsigned long port)
 {
         volatile unsigned char *addr = __ia64_mk_io_addr(port);
 
         *addr = val;
         __asm__ __volatile__ ("mf.a" ::: "memory");
 }
 
 static inline void
 __ia64_outw (unsigned short val, unsigned long port)
 {
         volatile unsigned short *addr = __ia64_mk_io_addr(port);
 
         *addr = val;
         __asm__ __volatile__ ("mf.a" ::: "memory");
 }
 
 static inline void
 __ia64_outl (unsigned int val, unsigned long port)
 {
         volatile unsigned int *addr = __ia64_mk_io_addr(port);
 
         *addr = val;
         __asm__ __volatile__ ("mf.a" ::: "memory");
 }
 
 static inline void
 __insb (unsigned long port, void *dst, unsigned long count)
 {
         unsigned char *dp = dst;
 
         if (__ia64_inb == __ia64_inb) {
                 volatile unsigned char *addr = __ia64_mk_io_addr(port);
 
                 __asm__ __volatile__ ("mf.a" ::: "memory");
                 while (count--)
                         *dp++ = *addr;
                 __asm__ __volatile__ ("mf.a" ::: "memory");
         } else
                 while (count--)
                         *dp++ = __ia64_inb(port);
         return;
 }
 
 static inline void
 __insw (unsigned long port, void *dst, unsigned long count)
 {
         unsigned short *dp = dst;
 
         if (__ia64_inw == __ia64_inw) {
                 volatile unsigned short *addr = __ia64_mk_io_addr(port);
 
                 __asm__ __volatile__ ("mf.a" ::: "memory");
                 while (count--)
                         *dp++ = *addr;
                 __asm__ __volatile__ ("mf.a" ::: "memory");
         } else
                 while (count--)
                         *dp++ = __ia64_inw(port);
         return;
 }
 
 static inline void
 __insl (unsigned long port, void *dst, unsigned long count)
 {
         unsigned int *dp = dst;
 
         if (__ia64_inl == __ia64_inl) {
                 volatile unsigned int *addr = __ia64_mk_io_addr(port);
 
                 __asm__ __volatile__ ("mf.a" ::: "memory");
                 while (count--)
                         *dp++ = *addr;
                 __asm__ __volatile__ ("mf.a" ::: "memory");
         } else
                 while (count--)
                         *dp++ = __ia64_inl(port);
         return;
 }
 
 static inline void
 __outsb (unsigned long port, const void *src, unsigned long count)
 {
         const unsigned char *sp = src;
 
         if (__ia64_outb == __ia64_outb) {
                 volatile unsigned char *addr = __ia64_mk_io_addr(port);
 
                 while (count--)
                         *addr = *sp++;
                 __asm__ __volatile__ ("mf.a" ::: "memory");
         } else
                 while (count--)
                         __ia64_outb(*sp++, port);
         return;
 }
 
 static inline void
 __outsw (unsigned long port, const void *src, unsigned long count)
 {
         const unsigned short *sp = src;
 
         if (__ia64_outw == __ia64_outw) {
                 volatile unsigned short *addr = __ia64_mk_io_addr(port);
 
                 while (count--)
                         *addr = *sp++;
                 __asm__ __volatile__ ("mf.a" ::: "memory");
         } else
                 while (count--)
                         __ia64_outw(*sp++, port);
         return;
 }
 
 static inline void
 __outsl (unsigned long port, void *src, unsigned long count)
 {
         const unsigned int *sp = src;
 
         if (__ia64_outl == __ia64_outl) {
                 volatile unsigned int *addr = __ia64_mk_io_addr(port);
 
                 while (count--)
                         *addr = *sp++;
                 __asm__ __volatile__ ("mf.a" ::: "memory");
         } else
                 while (count--)
                         __ia64_outl(*sp++, port);
         return;
 }
 # 309 "/data1/src/linux/include/asm/io.h"
 static inline unsigned char
 __readb (void *addr)
 {
         return *(volatile unsigned char *)addr;
 }
 
 static inline unsigned short
 __readw (void *addr)
 {
         return *(volatile unsigned short *)addr;
 }
 
 static inline unsigned int
 __readl (void *addr)
 {
         return *(volatile unsigned int *) addr;
 }
 
 static inline unsigned long
 __readq (void *addr)
 {
         return *(volatile unsigned long *) addr;
 }
 
 static inline void
 __writeb (unsigned char val, void *addr)
 {
         *(volatile unsigned char *) addr = val;
 }
 
 static inline void
 __writew (unsigned short val, void *addr)
 {
         *(volatile unsigned short *) addr = val;
 }
 
 static inline void
 __writel (unsigned int val, void *addr)
 {
         *(volatile unsigned int *) addr = val;
 }
 
 static inline void
 __writeq (unsigned long val, void *addr)
 {
         *(volatile unsigned long *) addr = val;
 }
 # 400 "/data1/src/linux/include/asm/io.h"
 static inline void *
 ioremap (unsigned long offset, unsigned long size)
 {
         return (void *) (0xc000000000000000 | (offset));
 }
 
 static inline void
 iounmap (void *addr)
 {
 }
 # 418 "/data1/src/linux/include/asm/io.h"
 extern void __ia64_memcpy_fromio (void *, unsigned long, long);
 extern void __ia64_memcpy_toio (unsigned long, void *, long);
 extern void __ia64_memset_c_io (unsigned long, unsigned long, long);
 # 21 "/data1/src/linux/include/asm/smp.h" 2
 # 32 "/data1/src/linux/include/asm/smp.h"
 extern struct smp_boot_data {
         int cpu_count;
         int cpu_phys_id[32];
 } smp_boot_data __attribute__ ((__section__ (".data.init")));
 
 extern char no_int_routing __attribute__ ((__section__ (".data.init")));
 
 extern volatile unsigned long cpu_online_map;
 extern unsigned long ipi_base_addr;
 extern unsigned char smp_int_redirect;
 extern int smp_num_cpus;
 
 extern volatile int ia64_cpu_to_sapicid[];
 
 
 
 
 extern unsigned long ap_wakeup_vector;
 
 
 
 
 
 static inline int
 cpu_logical_id (int cpuid)
 {
         int i;
 
         for (i = 0; i < smp_num_cpus; ++i)
                 if (ia64_cpu_to_sapicid[i] == (__u32) cpuid)
                         break;
         return i;
 }
 # 73 "/data1/src/linux/include/asm/smp.h"
 static inline void
 min_xtp (void)
 {
         if (smp_int_redirect & (1 << 0))
                 __writeb((0x00), (void *) (ipi_base_addr | 0x1e0008));
 }
 
 static inline void
 normal_xtp (void)
 {
         if (smp_int_redirect & (1 << 0))
                 __writeb((0x08), (void *) (ipi_base_addr | 0x1e0008));
 }
 
 static inline void
 max_xtp (void)
 {
         if (smp_int_redirect & (1 << 0))
                 __writeb((0x0f), (void *) (ipi_base_addr | 0x1e0008));
 }
 
 static inline unsigned int
 hard_smp_processor_id (void)
 {
         union {
                 struct {
                         unsigned long reserved : 16;
                         unsigned long eid : 8;
                         unsigned long id : 8;
                         unsigned long ignored : 32;
                 } f;
                 unsigned long bits;
         } lid;
 
         lid.bits = ia64_get_lid();
         return lid.f.id << 8 | lid.f.eid;
 }
 
 
 
 extern void __attribute__ ((__section__ (".text.init"))) init_smp_config (void);
 extern void smp_do_timer (struct pt_regs *regs);
 
 extern int smp_call_function_single (int cpuid, void (*func) (void *info), void *info,
                                      int retry, int wait);
 extern void smp_send_reschedule (int cpu);
 extern void smp_send_reschedule_all (void);
 # 15 "/data1/src/linux/include/linux/smp.h" 2
 # 24 "/data1/src/linux/include/linux/smp.h"
 extern void smp_send_stop(void);
 
 
 
 
 extern void smp_send_reschedule(int cpu);
 
 
 
 
 
 extern void smp_boot_cpus(void);
 
 
 
 
 extern void smp_commence(void);
 
 
 
 
 extern int smp_call_function (void (*func) (void *info), void *info,
                               int retry, int wait);
 
 
 
 
 extern volatile int smp_threads_ready;
 
 extern int smp_num_cpus;
 # 24 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/sem.h" 1
 
 
 
 # 1 "/data1/src/linux/include/linux/ipc.h" 1
 # 9 "/data1/src/linux/include/linux/ipc.h"
 struct ipc_perm
 {
         __kernel_key_t key;
         __kernel_uid_t uid;
         __kernel_gid_t gid;
         __kernel_uid_t cuid;
         __kernel_gid_t cgid;
         __kernel_mode_t mode;
         unsigned short seq;
 };
 
 
 # 1 "/data1/src/linux/include/asm/ipcbuf.h" 1
 # 14 "/data1/src/linux/include/asm/ipcbuf.h"
 struct ipc64_perm
 {
         __kernel_key_t key;
         __kernel_uid_t uid;
         __kernel_gid_t gid;
         __kernel_uid_t cuid;
         __kernel_gid_t cgid;
         __kernel_mode_t mode;
         unsigned short seq;
         unsigned short __pad1;
         unsigned long __unused1;
         unsigned long __unused2;
 };
 # 22 "/data1/src/linux/include/linux/ipc.h" 2
 # 57 "/data1/src/linux/include/linux/ipc.h"
 struct kern_ipc_perm
 {
         key_t key;
         uid_t uid;
         gid_t gid;
         uid_t cuid;
         gid_t cgid;
         mode_t mode;
         unsigned long seq;
 };
 # 5 "/data1/src/linux/include/linux/sem.h" 2
 # 23 "/data1/src/linux/include/linux/sem.h"
 struct semid_ds {
         struct ipc_perm sem_perm;
         __kernel_time_t sem_otime;
         __kernel_time_t sem_ctime;
         struct sem *sem_base;
         struct sem_queue *sem_pending;
         struct sem_queue **sem_pending_last;
         struct sem_undo *undo;
         unsigned short sem_nsems;
 };
 
 
 # 1 "/data1/src/linux/include/asm/sembuf.h" 1
 # 13 "/data1/src/linux/include/asm/sembuf.h"
 struct semid64_ds {
         struct ipc64_perm sem_perm;
         __kernel_time_t sem_otime;
         __kernel_time_t sem_ctime;
         unsigned long sem_nsems;
         unsigned long __unused1;
         unsigned long __unused2;
 };
 # 36 "/data1/src/linux/include/linux/sem.h" 2
 
 
 struct sembuf {
         unsigned short sem_num;
         short sem_op;
         short sem_flg;
 };
 
 
 union semun {
         int val;
         struct semid_ds *buf;
         unsigned short *array;
         struct seminfo *__buf;
         void *__pad;
 };
 
 struct seminfo {
         int semmap;
         int semmni;
         int semmns;
         int semmnu;
         int semmsl;
         int semopm;
         int semume;
         int semusz;
         int semvmx;
         int semaem;
 };
 # 82 "/data1/src/linux/include/linux/sem.h"
 struct sem {
         int semval;
         int sempid;
 };
 
 
 struct sem_array {
         struct kern_ipc_perm sem_perm;
         time_t sem_otime;
         time_t sem_ctime;
         struct sem *sem_base;
         struct sem_queue *sem_pending;
         struct sem_queue **sem_pending_last;
         struct sem_undo *undo;
         unsigned long sem_nsems;
 };
 
 
 struct sem_queue {
         struct sem_queue * next;
         struct sem_queue ** prev;
         struct task_struct* sleeper;
         struct sem_undo * undo;
         int pid;
         int status;
         struct sem_array * sma;
         int id;
         struct sembuf * sops;
         int nsops;
         int alter;
 };
 
 
 
 
 struct sem_undo {
         struct sem_undo * proc_next;
         struct sem_undo * id_next;
         int semid;
         short * semadj;
 };
 
  __attribute__((syscall_linkage)) long sys_semget (key_t key, int nsems, int semflg);
  __attribute__((syscall_linkage)) long sys_semop (int semid, struct sembuf *sops, unsigned nsops);
  __attribute__((syscall_linkage)) long sys_semctl (int semid, int semnum, int cmd, union semun arg);
 # 25 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/signal.h" 1
 
 
 
 # 1 "/data1/src/linux/include/asm/signal.h" 1
 # 136 "/data1/src/linux/include/asm/signal.h"
 struct siginfo;
 
 
 typedef void (*__sighandler_t)(int);
 
 typedef struct sigaltstack {
         void *ss_sp;
         int ss_flags;
         size_t ss_size;
 } stack_t;
 
 
 
 
 
 
 typedef unsigned long old_sigset_t;
 
 typedef struct {
         unsigned long sig[(64 / 64)];
 } sigset_t;
 
 struct sigaction {
         __sighandler_t sa_handler;
         unsigned long sa_flags;
         sigset_t sa_mask;
 };
 
 struct k_sigaction {
         struct sigaction sa;
 };
 
 # 1 "/data1/src/linux/include/asm/sigcontext.h" 1
 # 34 "/data1/src/linux/include/asm/sigcontext.h"
 struct sigcontext {
         unsigned long sc_flags;
         unsigned long sc_nat;
         stack_t sc_stack;
 
         unsigned long sc_ip;
         unsigned long sc_cfm;
         unsigned long sc_um;
         unsigned long sc_ar_rsc;
         unsigned long sc_ar_bsp;
         unsigned long sc_ar_rnat;
         unsigned long sc_ar_ccv;
         unsigned long sc_ar_unat;
         unsigned long sc_ar_fpsr;
         unsigned long sc_ar_pfs;
         unsigned long sc_ar_lc;
         unsigned long sc_pr;
         unsigned long sc_br[8];
 
         unsigned long sc_gr[32];
         struct ia64_fpreg sc_fr[128];
 
         unsigned long sc_rbs_base;
         unsigned long sc_loadrs;
 
         unsigned long sc_ar25;
         unsigned long sc_ar26;
         unsigned long sc_rsvd[12];
 
 
 
 
         sigset_t sc_mask;
 };
 # 169 "/data1/src/linux/include/asm/signal.h" 2
 # 5 "/data1/src/linux/include/linux/signal.h" 2
 # 1 "/data1/src/linux/include/asm/siginfo.h" 1
 # 11 "/data1/src/linux/include/asm/siginfo.h"
 typedef union sigval {
         int sival_int;
         void *sival_ptr;
 } sigval_t;
 
 
 
 
 typedef struct siginfo {
         int si_signo;
         int si_errno;
         int si_code;
         int __pad0;
 
         union {
                 int _pad[((128/sizeof(int)) - 4)];
 
 
                 struct {
                         pid_t _pid;
                         uid_t _uid;
                 } _kill;
 
 
                 struct {
                         unsigned int _timer1;
                         unsigned int _timer2;
                 } _timer;
 
 
                 struct {
                         pid_t _pid;
                         uid_t _uid;
                         sigval_t _sigval;
                 } _rt;
 
 
                 struct {
                         pid_t _pid;
                         uid_t _uid;
                         int _status;
                         clock_t _utime;
                         clock_t _stime;
                 } _sigchld;
 
 
                 struct {
                         void *_addr;
                         int _imm;
                         int _pad0;
                         unsigned long _isr;
                 } _sigfault;
 
 
                 struct {
                         long _band;
                         int _fd;
                 } _sigpoll;
 
                 struct {
                         pid_t _pid;
                         uid_t _uid;
                         unsigned long _pfm_ovfl_counters;
                 } _sigprof;
         } _sifields;
 } siginfo_t;
 # 230 "/data1/src/linux/include/asm/siginfo.h"
 typedef struct sigevent {
         sigval_t sigev_value;
         int sigev_signo;
         int sigev_notify;
         union {
                 int _pad[((64/sizeof(int)) - 4)];
 
                 struct {
                         void (*_function)(sigval_t);
                         void *_attribute;
                 } _sigev_thread;
         } _sigev_un;
 } sigevent_t;
 
 
 
 
 
 
 
 static inline void
 copy_siginfo (siginfo_t *to, siginfo_t *from)
 {
         if (from->si_code < 0)
                 memcpy(to, from, sizeof(siginfo_t));
         else
 
                 memcpy(to, from, 3*sizeof(int) + sizeof(from->_sifields._sigchld));
 }
 
 extern int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from);
 extern int copy_siginfo_from_user(siginfo_t *to, siginfo_t *from);
 # 6 "/data1/src/linux/include/linux/signal.h" 2
 
 
 
 
 
 
 struct sigqueue {
         struct sigqueue *next;
         siginfo_t info;
 };
 
 struct sigpending {
         struct sigqueue *head, **tail;
         sigset_t signal;
 };
 # 31 "/data1/src/linux/include/linux/signal.h"
 static inline void sigaddset(sigset_t *set, int _sig)
 {
         unsigned long sig = _sig - 1;
         if ((64 / 64) == 1)
                 set->sig[0] |= 1UL << sig;
         else
                 set->sig[sig / 64] |= 1UL << (sig % 64);
 }
 
 static inline void sigdelset(sigset_t *set, int _sig)
 {
         unsigned long sig = _sig - 1;
         if ((64 / 64) == 1)
                 set->sig[0] &= ~(1UL << sig);
         else
                 set->sig[sig / 64] &= ~(1UL << (sig % 64));
 }
 
 static inline int sigismember(sigset_t *set, int _sig)
 {
         unsigned long sig = _sig - 1;
         if ((64 / 64) == 1)
                 return 1 & (set->sig[0] >> sig);
         else
                 return 1 & (set->sig[sig / 64] >> (sig % 64));
 }
 
 static inline int sigfindinword(unsigned long word)
 {
         return ffz(~word);
 }
 # 108 "/data1/src/linux/include/linux/signal.h"
 static inline void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; unsigned long i; for (i = 0; i < (64 / 64)/4; ++i) { a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; a3 = a->sig[4 *i+3]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; b3 = b->sig[4*i+3]; r->sig[4*i+0] = ((a0) | (b0)); r->sig[4*i+1] = ((a1) | (b1)); r->sig[4*i+2] = ((a2) | (b2)); r->sig[4*i+3] = ((a3) | (b3)); } switch ((64 / 64) % 4) { case 3: a0 = a-> sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; r->sig[4*i+0] = ((a0) | (b0)); r->sig[4*i+1] = ((a1) | (b1)); r->sig[4*i+2] = ((a2) | (b2)); break; case 2: a0 = a->sig[4*i+0]; a1 = a->sig[4* i+1]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; r->sig[4*i+0] = ((a0) | (b0)); r->sig[4*i+1] = ((a1) | (b1)); break; case 1: a0 = a->sig[4*i+0]; b0 = b->sig[4*i+0]; r->sig[4*i+0] = ((a0) | (b0)); break; } }
 
 
 static inline void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; unsigned long i; for (i = 0; i < (64 / 64)/4; ++i) { a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; a3 = a->sig[ 4*i+3]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; b3 = b->sig[4*i+3]; r->sig[4*i+0] = ((a0) & (b0)); r->sig[4*i+1] = ((a1) & (b1)); r->sig[4*i+2] = ((a2) & (b2)); r->sig[4*i+3] = ((a3) & (b3)); } switch ((64 / 64) % 4) { case 3: a0 = a- >sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; r->sig[4*i+0] = ((a0) & (b0)); r->sig[4*i+1] = ((a1) & (b1)); r->sig[4*i+2] = ((a2) & (b2)); break; case 2: a0 = a->sig[4*i+0]; a1 = a->sig[4 *i+1]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; r->sig[4*i+0] = ((a0) & (b0)); r->sig[4*i+1] = ((a1) & (b1)); break; case 1: a0 = a->sig[4*i+0]; b0 = b->sig[4*i+0]; r->sig[4*i+0] = ((a0) & (b0)); break; } }
 
 
 static inline void signandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; unsigned long i; for (i = 0; i < (64 / 64)/4; ++i) { a0 = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; a3 = a->sig [4*i+3]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; b3 = b->sig[4*i+3]; r->sig[4*i+0] = ((a0) & ~(b0)); r->sig[4*i+1] = ((a1) & ~(b1)); r->sig[4*i+2] = ((a2) & ~(b2)); r->sig[4*i+3] = ((a3) & ~(b3)); } switch ((64 / 64) % 4) { case 3: a0  = a->sig[4*i+0]; a1 = a->sig[4*i+1]; a2 = a->sig[4*i+2]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; b2 = b->sig[4*i+2]; r->sig[4*i+0] = ((a0) & ~(b0)); r->sig[4*i+1] = ((a1) & ~(b1)); r->sig[4*i+2] = ((a2) & ~(b2)); break; case 2: a0 = a->sig[4*i+0]; a1 =  a->sig[4*i+1]; b0 = b->sig[4*i+0]; b1 = b->sig[4*i+1]; r->sig[4*i+0] = ((a0) & ~(b0)); r->sig[4*i+1] = ((a1) & ~(b1)); break; case 1: a0 = a->sig[4*i+0]; b0 = b->sig[4*i+0]; r->sig[4*i+0] = ((a0) & ~(b0)); break; } }
 # 140 "/data1/src/linux/include/linux/signal.h"
 static inline void signotset(sigset_t *set) { unsigned long i; for (i = 0; i < (64 / 64)/4; ++i) { set->sig[4*i+0] = (~(set->sig[4*i+0])); set->sig[4*i+1] = (~(set->sig[4*i+1])); set->sig[4*i+2] = (~(set->sig[4*i+2])); set->sig[4*i+3] = (~(set->sig[4*i+3 ])); } switch ((64 / 64) % 4) { case 3: set->sig[4*i+2] = (~(set->sig[4*i+2])); case 2: set->sig[4*i+1] = (~(set->sig[4*i+1])); case 1: set->sig[4*i+0] = (~(set->sig[4*i+0])); } }
 
 
 
 
 static inline void sigemptyset(sigset_t *set)
 {
         switch ((64 / 64)) {
         default:
                 memset(set, 0, sizeof(sigset_t));
                 break;
         case 2: set->sig[1] = 0;
         case 1: set->sig[0] = 0;
                 break;
         }
 }
 
 static inline void sigfillset(sigset_t *set)
 {
         switch ((64 / 64)) {
         default:
                 memset(set, -1, sizeof(sigset_t));
                 break;
         case 2: set->sig[1] = -1;
         case 1: set->sig[0] = -1;
                 break;
         }
 }
 
 extern char * render_sigset_t(sigset_t *set, char *buffer);
 
 
 
 static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
 {
         set->sig[0] |= mask;
 }
 
 static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
 {
         set->sig[0] &= ~mask;
 }
 
 static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
 {
         return (set->sig[0] & mask) != 0;
 }
 
 static inline void siginitset(sigset_t *set, unsigned long mask)
 {
         set->sig[0] = mask;
         switch ((64 / 64)) {
         default:
                 memset(&set->sig[1], 0, sizeof(long)*((64 / 64)-1));
                 break;
         case 2: set->sig[1] = 0;
         case 1: ;
         }
 }
 
 static inline void siginitsetinv(sigset_t *set, unsigned long mask)
 {
         set->sig[0] = ~mask;
         switch ((64 / 64)) {
         default:
                 memset(&set->sig[1], -1, sizeof(long)*((64 / 64)-1));
                 break;
         case 2: set->sig[1] = -1;
         case 1: ;
         }
 }
 
 
 
 static inline void init_sigpending(struct sigpending *sig)
 {
         sigemptyset(&sig->signal);
         sig->head = ((void *)0);
         sig->tail = &sig->head;
 }
 
 extern long do_sigpending(void *, unsigned long);
 # 26 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/securebits.h" 1
 
 
 
 
 
 extern unsigned securebits;
 # 27 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/fs_struct.h" 1
 
 
 
 
 struct fs_struct {
         atomic_t count;
         rwlock_t lock;
         int umask;
         struct dentry * root, * pwd, * altroot;
         struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
 };
 # 20 "/data1/src/linux/include/linux/fs_struct.h"
 extern void exit_fs(struct task_struct *);
 extern void set_fs_altroot(void);
 
 
 
 
 
 
 static inline void set_fs_root(struct fs_struct *fs,
         struct vfsmount *mnt,
         struct dentry *dentry)
 {
         struct dentry *old_root;
         struct vfsmount *old_rootmnt;
         do { __asm__ __volatile__ ( "mov ar.ccv = r0\n" "dep r29 = -1, r0, 31, 1\n" ";;\n" "1:\n" "ld4 r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" " (p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&fs->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while(0);
         old_root = fs->root;
         old_rootmnt = fs->rootmnt;
         fs->rootmnt = mntget(mnt);
         fs->root = dget(dentry);
         ({ __asm__ __volatile__ ("mf" ::: "memory"); clear_bit(31, (&fs->lock)); });
         if (old_root) {
                 dput(old_root);
                 mntput(old_rootmnt);
         }
 }
 
 
 
 
 
 
 static inline void set_fs_pwd(struct fs_struct *fs,
         struct vfsmount *mnt,
         struct dentry *dentry)
 {
         struct dentry *old_pwd;
         struct vfsmount *old_pwdmnt;
         do { __asm__ __volatile__ ( "mov ar.ccv = r0\n" "dep r29 = -1, r0, 31, 1\n" ";;\n" "1:\n" "ld4 r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" " (p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&fs->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while(0);
         old_pwd = fs->pwd;
         old_pwdmnt = fs->pwdmnt;
         fs->pwdmnt = mntget(mnt);
         fs->pwd = dget(dentry);
         ({ __asm__ __volatile__ ("mf" ::: "memory"); clear_bit(31, (&fs->lock)); });
         if (old_pwd) {
                 dput(old_pwd);
                 mntput(old_pwdmnt);
         }
 }
 
 struct fs_struct *copy_fs_struct(struct fs_struct *old);
 void put_fs_struct(struct fs_struct *fs);
 # 28 "/data1/src/linux/include/linux/sched.h" 2
 
 struct exec_domain;
 # 58 "/data1/src/linux/include/linux/sched.h"
 extern unsigned long avenrun[];
 # 75 "/data1/src/linux/include/linux/sched.h"
 extern int nr_threads;
 extern int last_pid;
 extern unsigned long nr_running(void);
 
 
 
 # 1 "/data1/src/linux/include/linux/param.h" 1
 # 82 "/data1/src/linux/include/linux/sched.h" 2
 # 1 "/data1/src/linux/include/linux/resource.h" 1
 # 21 "/data1/src/linux/include/linux/resource.h"
 struct rusage {
         struct timeval ru_utime;
         struct timeval ru_stime;
         long ru_maxrss;
         long ru_ixrss;
         long ru_idrss;
         long ru_isrss;
         long ru_minflt;
         long ru_majflt;
         long ru_nswap;
         long ru_inblock;
         long ru_oublock;
         long ru_msgsnd;
         long ru_msgrcv;
         long ru_nsignals;
         long ru_nvcsw;
         long ru_nivcsw;
 };
 
 struct rlimit {
         unsigned long rlim_cur;
         unsigned long rlim_max;
 };
 # 56 "/data1/src/linux/include/linux/resource.h"
 # 1 "/data1/src/linux/include/asm/resource.h" 1
 # 57 "/data1/src/linux/include/linux/resource.h" 2
 # 83 "/data1/src/linux/include/linux/sched.h" 2
 # 120 "/data1/src/linux/include/linux/sched.h"
 struct sched_param {
         int sched_priority;
 };
 
 struct completion;
 # 136 "/data1/src/linux/include/linux/sched.h"
 extern rwlock_t tasklist_lock;
 extern spinlock_t mmlist_lock;
 
 extern void sched_init(void);
 extern void init_idle(void);
 extern void show_state(void);
 extern void cpu_init (void);
 extern void trap_init(void);
 extern void update_process_times(int user);
 extern void update_one_process(struct task_struct *p, unsigned long user,
                                unsigned long system, int cpu);
 extern void expire_task(struct task_struct *p);
 extern void idle_tick(void);
 
 
 extern signed long schedule_timeout(signed long timeout);
  __attribute__((syscall_linkage)) void schedule(void);
 
 extern int schedule_task(struct tq_struct *task);
 extern void flush_scheduled_tasks(void);
 extern int start_context_thread(void);
 extern int current_is_keventd(void);
 
 
 
 
 
 
 
 struct namespace;
 
 
 
 struct files_struct {
         atomic_t count;
         rwlock_t file_lock;
         int max_fds;
         int max_fdset;
         int next_fd;
         struct file ** fd;
         fd_set *close_on_exec;
         fd_set *open_fds;
         fd_set close_on_exec_init;
         fd_set open_fds_init;
         struct file * fd_array[64];
 };
 # 201 "/data1/src/linux/include/linux/sched.h"
 struct mm_struct {
         struct vm_area_struct * mmap;
         rb_root_t mm_rb;
         struct vm_area_struct * mmap_cache;
         pgd_t * pgd;
         atomic_t mm_users;
         atomic_t mm_count;
         int map_count;
         struct rw_semaphore mmap_sem;
         spinlock_t page_table_lock;
 
         struct list_head mmlist;
 
 
 
 
         unsigned long start_code, end_code, start_data, end_data;
         unsigned long start_brk, brk, start_stack;
         unsigned long arg_start, arg_end, env_start, env_end;
         unsigned long rss, total_vm, locked_vm;
         unsigned long def_flags;
         unsigned long cpu_vm_mask;
         unsigned long swap_address;
 
         unsigned dumpable:1;
 
 
         mm_context_t context;
 };
 
 extern int mmlist_nr;
 # 244 "/data1/src/linux/include/linux/sched.h"
 struct signal_struct {
         atomic_t count;
         struct k_sigaction action[64];
         spinlock_t siglock;
 };
 # 260 "/data1/src/linux/include/linux/sched.h"
 struct user_struct {
         atomic_t __count;
         atomic_t processes;
         atomic_t files;
 
 
         struct user_struct *next, **pprev;
         uid_t uid;
 };
 
 
 
 
 
 
 extern struct user_struct root_user;
 
 
 typedef struct task_struct task_t;
 typedef struct prio_array prio_array_t;
 
 struct task_struct {
 
 
 
         volatile long state;
         unsigned long flags;
         int sigpending;
         mm_segment_t addr_limit;
 
 
 
         struct exec_domain *exec_domain;
         volatile long need_resched;
         unsigned long ptrace;
 
         int lock_depth;
 
 
 
 
         unsigned int cpu;
         int prio;
         long __nice;
         list_t run_list;
         prio_array_t *array;
 
         unsigned int time_slice;
         unsigned long sleep_jtime;
 
         unsigned long policy;
         unsigned long cpus_allowed;
 
         struct task_struct *next_task, *prev_task;
 
         struct mm_struct *mm, *active_mm;
         struct list_head local_pages;
 
         unsigned int allocation_order, nr_local_pages;
 
 
         struct linux_binfmt *binfmt;
         int exit_code, exit_signal;
         int pdeath_signal;
 
         unsigned long personality;
         int did_exec:1;
         pid_t pid;
         pid_t pgrp;
         pid_t tty_old_pgrp;
         pid_t session;
         pid_t tgid;
 
         int leader;
 
 
 
 
 
         struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
         struct list_head thread_group;
 
 
         struct task_struct *pidhash_next;
         struct task_struct **pidhash_pprev;
 
         wait_queue_head_t wait_chldexit;
         struct completion *vfork_done;
         unsigned long rt_priority;
         unsigned long it_real_value, it_prof_value, it_virt_value;
         unsigned long it_real_incr, it_prof_incr, it_virt_incr;
         struct timer_list real_timer;
         struct tms times;
         unsigned long start_time;
         long per_cpu_utime[32], per_cpu_stime[32];
 
         unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
         int swappable:1;
 
         uid_t uid,euid,suid,fsuid;
         gid_t gid,egid,sgid,fsgid;
         int ngroups;
         gid_t groups[32];
         kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
         int keep_capabilities:1;
         struct user_struct *user;
 
         struct rlimit rlim[11];
         unsigned short used_math;
         char comm[16];
 
         int link_count, total_link_count;
         struct tty_struct *tty;
         unsigned int locks;
 
         struct sem_undo *semundo;
         struct sem_queue *semsleeping;
 
         struct thread_struct thread;
 
         struct fs_struct *fs;
 
         struct files_struct *files;
 
         struct namespace *namespace;
 
         spinlock_t sigmask_lock;
         struct signal_struct *sig;
 
         sigset_t blocked;
         struct sigpending pending;
 
         unsigned long sas_ss_sp;
         size_t sas_ss_size;
         int (*notifier)(void *priv);
         void *notifier_data;
         sigset_t *notifier_mask;
 
 
         u32 parent_exec_id;
         u32 self_exec_id;
 
         spinlock_t alloc_lock;
 
 
         void *journal_info;
 };
 # 485 "/data1/src/linux/include/linux/sched.h"
 extern void set_cpus_allowed(task_t *p, unsigned long new_mask);
 extern void set_user_nice(task_t *p, long nice);
  __attribute__((syscall_linkage)) long sys_sched_yield(void);
 
 
 
 
 
 extern struct exec_domain default_exec_domain;
 # 546 "/data1/src/linux/include/linux/sched.h"
 union task_union {
         struct task_struct task;
         unsigned long stack[((1 << 1)*(1UL << 14))/sizeof(long)];
 };
 
 extern union task_union init_task_union;
 
 extern struct mm_struct init_mm;
 extern struct task_struct *init_tasks[32];
 
 
 
 extern struct task_struct *pidhash[(4096 >> 2)];
 
 
 
 static inline void hash_pid(struct task_struct *p)
 {
         struct task_struct **htable = &pidhash[((((p->pid) >> 8) ^ (p->pid)) & ((4096 >> 2) - 1))];
 
         if((p->pidhash_next = *htable) != ((void *)0))
                 (*htable)->pidhash_pprev = &p->pidhash_next;
         *htable = p;
         p->pidhash_pprev = htable;
 }
 
 static inline void unhash_pid(struct task_struct *p)
 {
         if(p->pidhash_next)
                 p->pidhash_next->pidhash_pprev = p->pidhash_pprev;
         *p->pidhash_pprev = p->pidhash_next;
 }
 
 static inline struct task_struct *find_task_by_pid(int pid)
 {
         struct task_struct *p, **htable = &pidhash[((((pid) >> 8) ^ (pid)) & ((4096 >> 2) - 1))];
 
         for(p = *htable; p && p->pid != pid; p = p->pidhash_next)
                 ;
 
         return p;
 }
 
 
 extern struct user_struct * alloc_uid(uid_t);
 extern void free_uid(struct user_struct *);
 
 
 
 extern unsigned long volatile jiffies;
 extern unsigned long itimer_ticks;
 extern unsigned long itimer_next;
 extern struct timeval xtime;
 extern void do_timer(struct pt_regs *);
 
 extern unsigned int * prof_buffer;
 extern unsigned long prof_len;
 extern unsigned long prof_shift;
 
 
 
 extern void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr);
 extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
 extern void sleep_on(wait_queue_head_t *q);
 extern long sleep_on_timeout(wait_queue_head_t *q, signed long timeout);
 
 extern void interruptible_sleep_on(wait_queue_head_t *q);
 extern long interruptible_sleep_on_timeout(wait_queue_head_t *q, signed long timeout);
 
 extern int wake_up_process(struct task_struct * tsk);
 extern void wake_up_forked_process(struct task_struct * tsk);
 # 628 "/data1/src/linux/include/linux/sched.h"
  __attribute__((syscall_linkage)) long sys_wait4(pid_t pid,unsigned int * stat_addr, int options, struct rusage * ru);
 
 extern int in_group_p(gid_t);
 extern int in_egroup_p(gid_t);
 
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *);
 extern int dequeue_signal(sigset_t *, siginfo_t *);
 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
                               sigset_t *mask);
 extern void unblock_all_signals(void);
 extern int send_sig_info(int, struct siginfo *, struct task_struct *);
 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
 extern int kill_pg_info(int, struct siginfo *, pid_t);
 extern int kill_sl_info(int, struct siginfo *, pid_t);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
 extern void notify_parent(struct task_struct *, int);
 extern void do_notify_parent(struct task_struct *, int);
 extern void force_sig(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
 extern int kill_pg(pid_t, int, int);
 extern int kill_sl(pid_t, int, int);
 extern int kill_proc(pid_t, int, int);
 extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
 extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);
 
 static inline int signal_pending(struct task_struct *p)
 {
         return (p->sigpending != 0);
 }
 
 
 
 
 
 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
 {
         unsigned long ready;
         long i;
 
         switch ((64 / 64)) {
         default:
                 for (i = (64 / 64), ready = 0; --i >= 0 ;)
                         ready |= signal->sig[i] &~ blocked->sig[i];
                 break;
 
         case 4: ready = signal->sig[3] &~ blocked->sig[3];
                 ready |= signal->sig[2] &~ blocked->sig[2];
                 ready |= signal->sig[1] &~ blocked->sig[1];
                 ready |= signal->sig[0] &~ blocked->sig[0];
                 break;
 
         case 2: ready = signal->sig[1] &~ blocked->sig[1];
                 ready |= signal->sig[0] &~ blocked->sig[0];
                 break;
 
         case 1: ready = signal->sig[0] &~ blocked->sig[0];
         }
         return ready != 0;
 }
 
 
 
 
 
 static inline void recalc_sigpending(struct task_struct *t)
 {
         t->sigpending = has_pending_signals(&t->pending.signal, &t->blocked);
 }
 
 
 
 static inline int on_sig_stack(unsigned long sp)
 {
         return (sp - current->sas_ss_sp < current->sas_ss_size);
 }
 
 static inline int sas_ss_flags(unsigned long sp)
 {
         return (current->sas_ss_size == 0 ? 2
                 : on_sig_stack(sp) ? 1 : 0);
 }
 
 extern int request_irq(unsigned int,
                        void (*handler)(int, void *, struct pt_regs *),
                        unsigned long, const char *, void *);
 extern void free_irq(unsigned int, void *);
 # 731 "/data1/src/linux/include/linux/sched.h"
 static inline int suser(void)
 {
         if (!( (1 << (0 +1)) & 0x00000000 ? (1 << (0)) & 0x00000000 : (1 << (0)) & securebits ) && current->euid == 0) {
                 current->flags |= 0x00000100;
                 return 1;
         }
         return 0;
 }
 
 static inline int fsuser(void)
 {
         if (!( (1 << (0 +1)) & 0x00000000 ? (1 << (0)) & 0x00000000 : (1 << (0)) & securebits ) && current->fsuid == 0) {
                 current->flags |= 0x00000100;
                 return 1;
         }
         return 0;
 }
 
 
 
 
 
 
 
 static inline int capable(int cap)
 {
 
         if (((current->cap_effective) & (1 << (cap))))
 
 
 
         {
                 current->flags |= 0x00000100;
                 return 1;
         }
         return 0;
 }
 
 
 
 
 extern struct mm_struct * mm_alloc(void);
 
 extern struct mm_struct * start_lazy_tlb(void);
 extern void end_lazy_tlb(struct mm_struct *mm);
 
 
 extern inline void __mmdrop(struct mm_struct *);
 static inline void mmdrop(struct mm_struct * mm)
 {
         if ((((__builtin_constant_p(1) && ( (1 == 1) || (1 == 4) || (1 == 8) || (1 == 16) || (1 == -1) || (1 == -4) || (1 == -8) || (1 == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&((&mm->mm_count))->counter)) *_v = (&((&mm->mm_count))->counter); swi tch (-(1)) { case -16: ({ switch (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp ) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) :  "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&((&mm->mm_c!
 ount))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __bad_ size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd 8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"( _tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switc!
 h (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory");  break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __v olatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&((&mm->mm_count))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel  %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); b!
 reak; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&((&mm->mm_count))->counter)) (_tmp + (-(1))); }) : ia64_atomic_sub(1, (&mm->mm_count))) == 0))
                 __mmdrop(mm);
 }
 
 
 extern void mmput(struct mm_struct *);
 
 extern void mm_release(void);
 
 
 
 
 extern struct file ** alloc_fd_array(int);
 extern int expand_fd_array(struct files_struct *, int nr);
 extern void free_fd_array(struct file **, int);
 
 extern fd_set *alloc_fdset(int);
 extern int expand_fdset(struct files_struct *, int nr);
 extern void free_fdset(fd_set *, int);
 
 extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
 extern void flush_thread(void);
 extern void exit_thread(void);
 
 extern void exit_mm(struct task_struct *);
 extern void exit_files(struct task_struct *);
 extern void exit_sighand(struct task_struct *);
 
 extern void reparent_to_init(void);
 extern void daemonize(void);
 extern task_t *child_reaper;
 
 extern int do_execve(char *, char **, char **, struct pt_regs *);
 extern int do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long);
 
 extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait);
 extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait);
 extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait);
 
 extern void wait_task_inactive(task_t * p);
 extern void kick_if_running(task_t * p);
 # 903 "/data1/src/linux/include/linux/sched.h"
 static inline void unhash_process(struct task_struct *p)
 {
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); do { __asm__ __volatile__ ( "mov ar.ccv = r0\n" "dep r29 = -1, r0, 31, 1\n" ";;\n" "1:\n" "ld4 r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2  = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&tasklist_lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while(0); } while (0);
         nr_threads--;
         unhash_pid(p);
         do { (p)->next_task->prev_task = (p)->prev_task; (p)->prev_task->next_task = (p)->next_task; if ((p)->p_osptr) (p)->p_osptr->p_ysptr = (p)->p_ysptr; if ((p)->p_ysptr) (p)->p_ysptr->p_osptr = (p)->p_osptr; else (p)->p_pptr->p_cptr = (p)->p_osptr;  } while (0);
         list_del(&p->thread_group);
         do { ({ __asm__ __volatile__ ("mf" ::: "memory"); clear_bit(31, (&tasklist_lock)); }); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 }
 
 
 static inline void task_lock(struct task_struct *p)
 {
         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond .spnt.few 1b\n" ";;\n" :: "r"(&(&p->alloc_lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
 }
 
 static inline void task_unlock(struct task_struct *p)
 {
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &p->alloc_lock)->lock = 0; } while (0);
 }
 
 
 static inline char * d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
                                 char *buf, int buflen)
 {
         char *res;
         struct vfsmount *rootmnt;
         struct dentry *root;
         do { int tmp = 0; __asm__ __volatile__ ("1:\tfetchadd4.acq %0 = [%1], 1\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 2f\n" ".section .text.lock,\"ax\"\n" "2:\tfetchadd4.rel %0 = [%1], -1\n" ";;\n" "3:\tld4.acq %0 = [%1]\n" ";;\n" " tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 3b\n" "br.cond.sptk.few 1b\n" ";;\n" ".previous\n" : "=&r" (tmp) : "r" (&current->fs->lock) : "p6", "memory"); } while(0);
         rootmnt = mntget(current->fs->rootmnt);
         root = dget(current->fs->root);
         do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&current->fs->lock) : "memory"); } while(0);
         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond .spnt.few 1b\n" ";;\n" :: "r"(&(&dcache_lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         res = __d_path(dentry, vfsmnt, root, rootmnt, buf, buflen);
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &dcache_lock)->lock = 0; } while (0);
         dput(root);
         mntput(rootmnt);
         return res;
 }
 # 5 "/data1/src/linux/include/linux/mm.h" 2
 
 
 
 
 
 # 1 "/data1/src/linux/include/linux/gfp.h" 1
 
 
 
 # 1 "/data1/src/linux/include/linux/mmzone.h" 1
 # 21 "/data1/src/linux/include/linux/mmzone.h"
 typedef struct free_area_struct {
         struct list_head free_list;
         unsigned long *map;
 } free_area_t;
 
 struct pglist_data;
 # 36 "/data1/src/linux/include/linux/mmzone.h"
 typedef struct zone_struct {
 
 
 
         spinlock_t lock;
         unsigned long free_pages;
         unsigned long pages_min, pages_low, pages_high;
         int need_balance;
 
 
 
 
         free_area_t free_area[10];
 
 
 
 
         struct pglist_data *zone_pgdat;
         struct page *zone_mem_map;
         unsigned long zone_start_paddr;
         unsigned long zone_start_mapnr;
 
 
 
 
         char *name;
         unsigned long size;
 } zone_t;
 # 81 "/data1/src/linux/include/linux/mmzone.h"
 typedef struct zonelist_struct {
         zone_t * zones [3 +1];
 } zonelist_t;
 # 98 "/data1/src/linux/include/linux/mmzone.h"
 struct bootmem_data;
 typedef struct pglist_data {
         zone_t node_zones[3];
         zonelist_t node_zonelists[0x0f +1];
         int nr_zones;
         struct page *node_mem_map;
         unsigned long *valid_addr_bitmap;
         struct bootmem_data *bdata;
         unsigned long node_start_paddr;
         unsigned long node_start_mapnr;
         unsigned long node_size;
         int node_id;
         struct pglist_data *node_next;
 } pg_data_t;
 
 extern int numnodes;
 extern pg_data_t *pgdat_list;
 # 123 "/data1/src/linux/include/linux/mmzone.h"
 struct page;
 extern void show_free_areas_core(pg_data_t *pgdat);
 extern void free_area_init_core(int nid, pg_data_t *pgdat, struct page **gmap,
   unsigned long *zones_size, unsigned long paddr, unsigned long *zholes_size,
   struct page *pmap);
 
 extern pg_data_t contig_page_data;
 # 5 "/data1/src/linux/include/linux/gfp.h" 2
 # 42 "/data1/src/linux/include/linux/gfp.h"
 extern struct page * _alloc_pages(unsigned int gfp_mask, unsigned int order);
 extern struct page * __alloc_pages(unsigned int gfp_mask, unsigned int order, zonelist_t *zonelist);
 extern struct page * alloc_pages_node(int nid, unsigned int gfp_mask, unsigned int order);
 
 static inline struct page * alloc_pages(unsigned int gfp_mask, unsigned int order)
 {
 
 
 
         if (order >= 10)
                 return ((void *)0);
         return _alloc_pages(gfp_mask, order);
 }
 
 
 
 extern unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order);
 extern unsigned long get_zeroed_page(unsigned int gfp_mask);
 # 75 "/data1/src/linux/include/linux/gfp.h"
 extern void __free_pages(struct page *page, unsigned int order);
 extern void free_pages(unsigned long addr, unsigned int order);
 # 11 "/data1/src/linux/include/linux/mm.h" 2
 
 
 
 # 1 "/data1/src/linux/include/linux/swap.h" 1
 # 25 "/data1/src/linux/include/linux/swap.h"
 union swap_header {
         struct
         {
                 char reserved[(1UL << 14) - 10];
                 char magic[10];
         } magic;
         struct
         {
                 char bootbits[1024];
                 unsigned int version;
                 unsigned int last_page;
                 unsigned int nr_badpages;
                 unsigned int padding[125];
                 unsigned int badpages[1];
         } info;
 };
 # 64 "/data1/src/linux/include/linux/swap.h"
 struct swap_info_struct {
         unsigned int flags;
         kdev_t swap_device;
         spinlock_t sdev_lock;
         struct file *swap_file;
         unsigned short * swap_map;
         unsigned int lowest_bit;
         unsigned int highest_bit;
         unsigned int cluster_next;
         unsigned int cluster_nr;
         int prio;
         int pages;
         unsigned long max;
         int next;
 };
 
 extern int nr_swap_pages;
 
 
 
 
 extern unsigned int nr_free_pages(void);
 extern unsigned int nr_free_buffer_pages(void);
 extern int nr_active_pages;
 extern int nr_inactive_pages;
 extern atomic_t nr_async_pages;
 extern atomic_t page_cache_size;
 extern atomic_t buffermem_pages;
 extern spinlock_t pagecache_lock;
 extern void __remove_inode_page(struct page *);
 
 
 struct task_struct;
 struct vm_area_struct;
 struct sysinfo;
 
 struct zone_t;
 
 
 extern void lru_cache_add(struct page *);
 extern void __lru_cache_del(struct page *);
 extern void lru_cache_del(struct page *);
 
 extern void activate_page(struct page *);
 
 extern void swap_setup(void);
 
 
 extern wait_queue_head_t kswapd_wait;
 extern int try_to_free_pages(zone_t *, unsigned int, unsigned int);
 
 
 extern void rw_swap_page(int, struct page *);
 extern void rw_swap_page_nolock(int, swp_entry_t, char *);
 
 
 
 
 
 
 extern void show_swap_cache_info(void);
 
 extern int add_to_swap_cache(struct page *, swp_entry_t);
 extern void __delete_from_swap_cache(struct page *page);
 extern void delete_from_swap_cache(struct page *page);
 extern void free_page_and_swap_cache(struct page *page);
 extern struct page * lookup_swap_cache(swp_entry_t);
 extern struct page * read_swap_cache_async(swp_entry_t);
 
 
 extern void out_of_memory(void);
 
 
 extern int total_swap_pages;
 extern unsigned int nr_swapfiles;
 extern struct swap_info_struct swap_info[];
 extern int is_swap_partition(kdev_t);
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
 extern void get_swaphandle_info(swp_entry_t, unsigned long *, struct inode **);
 extern int swap_duplicate(swp_entry_t);
 extern int swap_count(struct page *);
 extern int valid_swaphandles(swp_entry_t, unsigned long *);
 extern void swap_free(swp_entry_t);
 extern void free_swap_and_cache(swp_entry_t);
 struct swap_list_t {
         int head;
         int next;
 };
 extern struct swap_list_t swap_list;
  __attribute__((syscall_linkage)) long sys_swapoff(const char *);
  __attribute__((syscall_linkage)) long sys_swapon(const char *, int);
 
 extern spinlock_t pagemap_lru_lock;
 
 extern void mark_page_accessed(struct page *);
 # 201 "/data1/src/linux/include/linux/swap.h"
 extern spinlock_t swaplock;
 
 
 
 
 
 
 extern void shmem_unuse(swp_entry_t entry, struct page *page);
 # 15 "/data1/src/linux/include/linux/mm.h" 2
 
 
 extern unsigned long max_mapnr;
 extern unsigned long num_physpages;
 extern void * high_memory;
 extern int page_cluster;
 
 extern struct list_head active_list;
 extern struct list_head inactive_list;
 
 
 # 1 "/data1/src/linux/include/asm/pgtable.h" 1
 # 17 "/data1/src/linux/include/asm/pgtable.h"
 # 1 "/data1/src/linux/include/asm/mman.h" 1
 # 18 "/data1/src/linux/include/asm/pgtable.h" 2
 # 129 "/data1/src/linux/include/asm/pgtable.h"
 # 1 "/data1/src/linux/include/asm/mmu_context.h" 1
 # 31 "/data1/src/linux/include/asm/mmu_context.h"
 struct ia64_ctx {
         spinlock_t lock;
         unsigned int next;
         unsigned int limit;
         unsigned int max_ctx;
 };
 
 extern struct ia64_ctx ia64_ctx;
 
 extern void wrap_mmu_context (struct mm_struct *mm);
 
 static inline void
 enter_lazy_tlb (struct mm_struct *mm, struct task_struct *tsk, unsigned cpu)
 {
 }
 
 static inline void
 get_new_mmu_context (struct mm_struct *mm)
 {
         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond .spnt.few 1b\n" ";;\n" :: "r"(&(&ia64_ctx.lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         {
                 if (ia64_ctx.next >= ia64_ctx.limit)
                         wrap_mmu_context(mm);
                 mm->context = ia64_ctx.next++;
         }
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &ia64_ctx.lock)->lock = 0; } while (0);
 
 }
 
 static inline void
 get_mmu_context (struct mm_struct *mm)
 {
         if (mm->context == 0)
                 get_new_mmu_context(mm);
 }
 
 static inline int
 init_new_context (struct task_struct *p, struct mm_struct *mm)
 {
         mm->context = 0;
         return 0;
 }
 
 static inline void
 destroy_context (struct mm_struct *mm)
 {
 
 }
 
 static inline void
 reload_context (struct mm_struct *mm)
 {
         unsigned long rid;
         unsigned long rid_incr = 0;
         unsigned long rr0, rr1, rr2, rr3, rr4;
 
         rid = mm->context << 3;
         rid_incr = 1 << 8;
 
 
         rr0 = (rid << 8) | (14 << 2) | 1;
         rr1 = rr0 + 1*rid_incr;
         rr2 = rr0 + 2*rid_incr;
         rr3 = rr0 + 3*rid_incr;
         rr4 = rr0 + 4*rid_incr;
         ia64_set_rr(0x0000000000000000, rr0);
         ia64_set_rr(0x2000000000000000, rr1);
         ia64_set_rr(0x4000000000000000, rr2);
         ia64_set_rr(0x6000000000000000, rr3);
         ia64_set_rr(0x8000000000000000, rr4);
         ia64_insn_group_barrier();
         ia64_srlz_i();
         ia64_insn_group_barrier();
 }
 
 
 
 
 static inline void
 activate_mm (struct mm_struct *prev, struct mm_struct *next)
 {
 
 
 
 
         ia64_set_kr(7, ({ia64_va _v; _v.l = (long) (next->pgd); _v.f.reg = 0; _v.l;}));
         get_mmu_context(next);
         reload_context(next);
 }
 # 130 "/data1/src/linux/include/asm/pgtable.h" 2
 # 176 "/data1/src/linux/include/asm/pgtable.h"
 static inline long
 ia64_phys_addr_valid (unsigned long addr)
 {
         return (addr & (((struct cpuinfo_ia64 *) (0xa000000000000000 + 2*(1UL << 14)))->unimpl_pa_mask)) == 0;
 }
 # 306 "/data1/src/linux/include/asm/pgtable.h"
 static inline unsigned long
 rgn_index (unsigned long address)
 {
         ia64_va a;
 
         a.l = address;
         return a.f.reg;
 }
 
 
 
 
 static inline unsigned long
 rgn_offset (unsigned long address)
 {
         ia64_va a;
 
         a.l = address;
         return a.f.off;
 }
 
 static inline unsigned long
 pgd_index (unsigned long address)
 {
         unsigned long region = address >> 61;
         unsigned long l1index = (address >> (14 + 2*(14 -3))) & (((((unsigned long)(1)) << (14 -3)) >> 3) - 1);
 
         return (region << (14 - 6)) | l1index;
 }
 
 
 
 static inline pgd_t*
 pgd_offset (struct mm_struct *mm, unsigned long address)
 {
         return mm->pgd + pgd_index(address);
 }
 # 359 "/data1/src/linux/include/asm/pgtable.h"
 static inline int
 ptep_test_and_clear_young (pte_t *ptep)
 {
 
         return test_and_clear_bit(5, ptep);
 
 
 
 
 
 
 
 }
 
 static inline int
 ptep_test_and_clear_dirty (pte_t *ptep)
 {
 
         return test_and_clear_bit(6, ptep);
 
 
 
 
 
 
 
 }
 
 static inline pte_t
 ptep_get_and_clear (pte_t *ptep)
 {
 
         return ((pte_t) { (((__typeof__(*((long *) ptep))) __xchg ((unsigned long) (0), ((long *) ptep), sizeof(*((long *) ptep))))) } );
 
 
 
 
 
 }
 
 static inline void
 ptep_set_wrprotect (pte_t *ptep)
 {
 
         unsigned long new, old;
 
         do {
                 old = ((*ptep).pte);
                 new = (((((pte_t) { (((((pte_t) { (old) } )).pte) & ~(2 << 9)) } ))).pte);
         } while (({ __typeof__(((unsigned long *) ptep)) _p_ = (((unsigned long *) ptep)); __typeof__((new)) _n_ = ((new)); __u64 _o_, _r_; switch (sizeof(*((unsigned long *) ptep))) { case 1: _o_ = (__u8 ) (long) ((old)); break; case 2: _o_ = (__u16) (l ong) ((old)); break; case 4: _o_ = (__u32) (long) ((old)); break; case 8: _o_ = (__u64) (long) ((old)); break; default: break; } __asm__ __volatile__ ("mov ar.ccv=%0;;" :: "rO"(_o_)); switch (sizeof(*((unsigned long *) ptep))) { case 1: __asm__ __volatil e__ ("cmpxchg1.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 2: __asm__ __volatile__ ("cmpxchg2.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 4: __asm__ __volatile__ ("cmpxchg4 .""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; case 8: __asm__ __volatile__ ("cmpxchg8.""acq"" %0=[%1],%2,ar.ccv" : "=r"(_r_) : "r"(_p_), "r"(_n_) : "memory"); break; default: _r_ = __cmpxchg_c!
 alled_with_bad_pointer(); break; } (__typeof__((old))) _r_; }) != old);
 
 
 
 
 }
 
 static inline void
 ptep_mkdirty (pte_t *ptep)
 {
 
         set_bit(6, ptep);
 
 
 
 
 }
 
 static inline int
 pte_same (pte_t a, pte_t b)
 {
         return ((a).pte) == ((b).pte);
 }
 
 
 
 
 
 static inline int
 is_write_access (int access_type)
 {
         return (access_type & 0x2);
 }
 
 static inline int
 is_exec_access (int access_type)
 {
         return (access_type & 0x4);
 }
 
 extern pgd_t swapper_pg_dir[(((unsigned long)(1)) << (14 -3))];
 extern void paging_init (void);
 # 466 "/data1/src/linux/include/asm/pgtable.h"
 extern unsigned long empty_zero_page[(1UL << 14)/sizeof(unsigned long)];
 # 27 "/data1/src/linux/include/linux/mm.h" 2
 # 44 "/data1/src/linux/include/linux/mm.h"
 struct vm_area_struct {
         struct mm_struct * vm_mm;
         unsigned long vm_start;
         unsigned long vm_end;
 
 
 
         struct vm_area_struct *vm_next;
 
         pgprot_t vm_page_prot;
         unsigned long vm_flags;
 
         rb_node_t vm_rb;
 
 
 
 
 
 
         struct vm_area_struct *vm_next_share;
         struct vm_area_struct **vm_pprev_share;
 
 
         struct vm_operations_struct * vm_ops;
 
 
         unsigned long vm_pgoff;
 
         struct file * vm_file;
         unsigned long vm_raend;
         void * vm_private_data;
 };
 # 128 "/data1/src/linux/include/linux/mm.h"
 extern pgprot_t protection_map[16];
 
 
 
 
 
 
 
 struct vm_operations_struct {
         void (*open)(struct vm_area_struct * area);
         void (*close)(struct vm_area_struct * area);
         struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int unused);
 };
 # 157 "/data1/src/linux/include/linux/mm.h"
 typedef struct page {
         struct list_head list;
         struct address_space *mapping;
         unsigned long index;
         struct page *next_hash;
 
         atomic_t count;
         unsigned long flags;
 
         struct list_head lru;
 
         wait_queue_head_t wait;
         struct page **pprev_hash;
         struct buffer_head * buffers;
         void *virtual;
 
         struct zone_struct *zone;
 } mem_map_t;
 # 311 "/data1/src/linux/include/linux/mm.h"
 extern void set_page_dirty(struct page *);
 # 355 "/data1/src/linux/include/linux/mm.h"
 extern mem_map_t * mem_map;
 
 extern void show_free_areas(void);
 extern void show_free_areas_node(pg_data_t *pgdat);
 
 extern void clear_page_tables(struct mm_struct *, unsigned long, int);
 
 extern int fail_writepage(struct page *);
 struct page * shmem_nopage(struct vm_area_struct * vma, unsigned long address, int unused);
 struct file *shmem_file_setup(char * name, loff_t size);
 extern void shmem_lock(struct file * file, int lock);
 extern int shmem_zero_setup(struct vm_area_struct *);
 
 extern void zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size);
 extern int copy_page_range(struct mm_struct *dst, struct mm_struct *src, struct vm_area_struct *vma);
 extern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot);
 extern int zeromap_page_range(unsigned long from, unsigned long size, pgprot_t prot);
 
 extern int vmtruncate(struct inode * inode, loff_t offset);
 extern pmd_t *__pmd_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
 extern pte_t *pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address);
 extern int handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
 extern int make_pages_present(unsigned long addr, unsigned long end);
 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
 extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char *dst, int len);
 extern int ptrace_writedata(struct task_struct *tsk, char * src, unsigned long dst, int len);
 extern int ptrace_attach(struct task_struct *tsk);
 extern int ptrace_detach(struct task_struct *, unsigned int);
 extern void ptrace_disable(struct task_struct *);
 extern int ptrace_check_attach(struct task_struct *task, int kill);
 
 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
                 int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
 
 
 
 
 
 
 static inline pmd_t *pmd_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
 {
         if ((!((*pgd).pgd)))
                 return __pmd_alloc(mm, pgd, address);
         return ((pmd_t *) ((unsigned long) ({ia64_va _v; _v.l = (long) (((*(pgd)).pgd) & (((((unsigned long)(1)) << 50) - 1) & ~0xfffUL)); _v.f.reg = -1; _v.p;})) + (((address) >> (14 + (14 -3))) & ((((unsigned long)(1)) << (14 -3)) - 1)));
 }
 
 extern int pgt_cache_water[2];
 extern int check_pgt_cache(void);
 
 extern void free_area_init(unsigned long * zones_size);
 extern void free_area_init_node(int nid, pg_data_t *pgdat, struct page *pmap,
         unsigned long * zones_size, unsigned long zone_start_paddr,
         unsigned long *zholes_size);
 extern void mem_init(void);
 extern void show_mem(void);
 extern void si_meminfo(struct sysinfo * val);
 extern void swapin_readahead(swp_entry_t);
 
 extern struct address_space swapper_space;
 
 
 static inline int is_page_cache_freeable(struct page * page)
 {
         return ((&(page)->count)->counter) - !!page->buffers == 1;
 }
 
 extern int can_share_swap_page(struct page *);
 extern int remove_exclusive_swap_page(struct page *);
 
 extern void __free_pte(pte_t);
 
 
 extern void lock_vma_mappings(struct vm_area_struct *);
 extern void unlock_vma_mappings(struct vm_area_struct *);
 extern void insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
 extern void __insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
 extern void build_mmap_rb(struct mm_struct *);
 extern void exit_mmap(struct mm_struct *);
 
 extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 
 extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot,
         unsigned long flag, unsigned long pgoff);
 
 static inline unsigned long do_mmap(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot,
         unsigned long flag, unsigned long offset)
 {
         unsigned long ret = -22;
         if ((offset + (((len) + (1UL << 14) - 1) & (~((1UL << 14) - 1)))) < offset)
                 goto out;
         if (!(offset & ~(~((1UL << 14) - 1))))
                 ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> 14);
 out:
         return ret;
 }
 
 extern int do_munmap(struct mm_struct *, unsigned long, size_t);
 
 extern unsigned long do_brk(unsigned long, unsigned long);
 
 static inline void __vma_unlink(struct mm_struct * mm, struct vm_area_struct * vma, struct vm_area_struct * prev)
 {
         prev->vm_next = vma->vm_next;
         rb_erase(&vma->vm_rb, &mm->mm_rb);
         if (mm->mmap_cache == vma)
                 mm->mmap_cache = prev;
 }
 
 static inline int can_vma_merge(struct vm_area_struct * vma, unsigned long vm_flags)
 {
         if (!vma->vm_file && vma->vm_flags == vm_flags)
                 return 1;
         else
                 return 0;
 }
 
 struct zone_t;
 
 extern void remove_inode_page(struct page *);
 extern unsigned long page_unuse(struct page *);
 extern void truncate_inode_pages(struct address_space *, loff_t);
 
 
 extern int filemap_sync(struct vm_area_struct *, unsigned long, size_t, unsigned int);
 extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int);
 
 
 
 static inline int expand_stack(struct vm_area_struct * vma, unsigned long address)
 {
         unsigned long grow;
 
 
 
 
 
 
         address &= (~((1UL << 14) - 1));
         grow = (vma->vm_start - address) >> 14;
         if (vma->vm_end - address > current->rlim[3].rlim_cur ||
             ((vma->vm_mm->total_vm + grow) << 14) > current->rlim[9].rlim_cur)
                 return -12;
         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond .spnt.few 1b\n" ";;\n" :: "r"(&(&vma->vm_mm->page_table_lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         vma->vm_start = address;
         vma->vm_pgoff -= grow;
         vma->vm_mm->total_vm += grow;
         if (vma->vm_flags & 0x00002000)
                 vma->vm_mm->locked_vm += grow;
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &vma->vm_mm->page_table_lock)->lock = 0; } while (0);
         return 0;
 }
 
 
 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
 extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
                                              struct vm_area_struct **pprev);
 
 
 
 static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
 {
         struct vm_area_struct * vma = find_vma(mm,start_addr);
 
         if (vma && end_addr <= vma->vm_start)
                 vma = ((void *)0);
         return vma;
 }
 
 extern struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr);
 # 16 "kernel/sched.c" 2
 # 1 "/data1/src/linux/include/linux/nmi.h" 1
 
 
 
 
 
 
 # 1 "/data1/src/linux/include/asm/irq.h" 1
 # 16 "/data1/src/linux/include/asm/irq.h"
 static __inline__ int
 irq_cannonicalize (int irq)
 {
 
 
 
 
 
         return ((irq == 2) ? 9 : irq);
 }
 
 extern void disable_irq (unsigned int);
 extern void disable_irq_nosync (unsigned int);
 extern void enable_irq (unsigned int);
 # 8 "/data1/src/linux/include/linux/nmi.h" 2
 # 17 "kernel/sched.c" 2
 
 # 1 "/data1/src/linux/include/asm/uaccess.h" 1
 # 63 "/data1/src/linux/include/asm/uaccess.h"
 static inline int
 verify_area (int type, const void *addr, unsigned long size)
 {
         return (((unsigned long) ((addr))) <= ((current->addr_limit)).seg && (((current->addr_limit)).seg == ((mm_segment_t) { ~0UL }).seg || rgn_offset((unsigned long) ((addr))) < ((1UL << (4*14 - 12)) - (1UL << 14)))) ? 0 : -14;
 }
 # 88 "/data1/src/linux/include/asm/uaccess.h"
 extern void __get_user_unknown (void);
 # 124 "/data1/src/linux/include/asm/uaccess.h"
 struct __large_struct { unsigned long buf[100]; };
 
 
 
 asm (".section \"__ex_table\", \"a\"\n\t.previous");
 # 164 "/data1/src/linux/include/asm/uaccess.h"
 extern void __put_user_unknown (void);
 # 232 "/data1/src/linux/include/asm/uaccess.h"
 extern unsigned long __copy_user (void *to, const void *from, unsigned long count);
 # 252 "/data1/src/linux/include/asm/uaccess.h"
 extern unsigned long __do_clear_user (void *, unsigned long);
 # 272 "/data1/src/linux/include/asm/uaccess.h"
 extern long __strncpy_from_user (char *to, const char *from, long to_len);
 # 284 "/data1/src/linux/include/asm/uaccess.h"
 extern unsigned long __strlen_user (const char *);
 # 300 "/data1/src/linux/include/asm/uaccess.h"
 extern unsigned long __strnlen_user (const char *, long);
 # 311 "/data1/src/linux/include/asm/uaccess.h"
 struct exception_table_entry {
         int addr;
         int cont;
 };
 
 struct exception_fixup {
         unsigned long cont;
 };
 
 extern struct exception_fixup search_exception_table (unsigned long addr);
 extern void handle_exception (struct pt_regs *regs, struct exception_fixup fixup);
 # 19 "kernel/sched.c" 2
 # 1 "/data1/src/linux/include/linux/smp_lock.h" 1
 # 16 "/data1/src/linux/include/linux/smp_lock.h"
 # 1 "/data1/src/linux/include/asm/smplock.h" 1
 
 
 
 
 
 # 1 "/data1/src/linux/include/linux/interrupt.h" 1
 # 16 "/data1/src/linux/include/linux/interrupt.h"
 struct irqaction {
         void (*handler)(int, void *, struct pt_regs *);
         unsigned long flags;
         unsigned long mask;
         const char *name;
         void *dev_id;
         struct irqaction *next;
 };
 
 
 
 
 
 enum {
         TIMER_BH = 0,
         TQUEUE_BH,
         DIGI_BH,
         SERIAL_BH,
         RISCOM8_BH,
         SPECIALIX_BH,
         AURORA_BH,
         ESP_BH,
         SCSI_BH,
         IMMEDIATE_BH,
         CYCLADES_BH,
         CM206_BH,
         JS_BH,
         MACSERIAL_BH,
         ISICOM_BH
 };
 
 # 1 "/data1/src/linux/include/asm/hardirq.h" 1
 # 12 "/data1/src/linux/include/asm/hardirq.h"
 # 1 "/data1/src/linux/include/linux/irq.h" 1
 # 39 "/data1/src/linux/include/linux/irq.h"
 struct hw_interrupt_type {
         const char * typename;
         unsigned int (*startup)(unsigned int irq);
         void (*shutdown)(unsigned int irq);
         void (*enable)(unsigned int irq);
         void (*disable)(unsigned int irq);
         void (*ack)(unsigned int irq);
         void (*end)(unsigned int irq);
         void (*set_affinity)(unsigned int irq, unsigned long mask);
 };
 
 typedef struct hw_interrupt_type hw_irq_controller;
 # 59 "/data1/src/linux/include/linux/irq.h"
 typedef struct irq_desc {
         unsigned int status;
         hw_irq_controller *handler;
         struct irqaction *action;
         unsigned int depth;
         spinlock_t lock;
 } __attribute__((__aligned__((1 << (6))))) irq_desc_t;
 
 # 1 "/data1/src/linux/include/asm/hw_irq.h" 1
 # 16 "/data1/src/linux/include/asm/hw_irq.h"
 typedef u8 ia64_vector;
 # 60 "/data1/src/linux/include/asm/hw_irq.h"
 enum {
         IA64_IPI_DM_INT = 0x0,
         IA64_IPI_DM_PMI = 0x2,
         IA64_IPI_DM_NMI = 0x4,
         IA64_IPI_DM_INIT = 0x5,
         IA64_IPI_DM_EXTINT = 0x7,
 };
 
 extern __u8 isa_irq_to_vector_map[16];
 
 
 extern unsigned long ipi_base_addr;
 
 extern struct hw_interrupt_type irq_type_ia64_lsapic;
 
 extern int ia64_alloc_irq (void);
 extern void ia64_send_ipi (int cpu, int vector, int delivery_mode, int redirect);
 extern void register_percpu_irq (ia64_vector vec, struct irqaction *action);
 
 static inline void
 hw_resend_irq (struct hw_interrupt_type *h, unsigned int vector)
 {
         ia64_send_ipi((current->cpu), vector, IA64_IPI_DM_INT, 0);
 }
 
 
 
 
 
 extern struct irq_desc _irq_desc[256];
 
 static inline struct irq_desc *
 __ia64_irq_desc (unsigned int irq)
 {
         return _irq_desc + irq;
 }
 
 static inline ia64_vector
 __ia64_irq_to_vector (unsigned int irq)
 {
         return (ia64_vector) irq;
 }
 
 static inline unsigned int
 __ia64_local_vector_to_irq (ia64_vector vec)
 {
         return (unsigned int) vec;
 }
 # 120 "/data1/src/linux/include/asm/hw_irq.h"
 static inline struct irq_desc *
 irq_desc (int irq)
 {
         return __ia64_irq_desc(irq);
 }
 
 
 static inline ia64_vector
 irq_to_vector (int irq)
 {
         return __ia64_irq_to_vector(irq);
 }
 
 
 
 
 
 
 static inline unsigned int
 local_vector_to_irq (ia64_vector vec)
 {
         return __ia64_local_vector_to_irq(vec);
 }
 # 68 "/data1/src/linux/include/linux/irq.h" 2
 
 extern int handle_IRQ_event(unsigned int, struct pt_regs *, struct irqaction *);
 extern int setup_irq(unsigned int , struct irqaction * );
 
 extern hw_irq_controller no_irq_type;
 extern void no_action(int cpl, void *dev_id, struct pt_regs *regs);
 # 13 "/data1/src/linux/include/asm/hardirq.h" 2
 # 53 "/data1/src/linux/include/asm/hardirq.h"
 extern unsigned int global_irq_holder;
 extern volatile unsigned long global_irq_lock;
 
 static inline int
 irqs_running (void)
 {
         int i;
 
         for (i = 0; i < smp_num_cpus; i++)
                 if (((&_cpu_data[i])->irq_stat.f.irq_count))
                         return 1;
         return 0;
 }
 
 static inline void
 release_irqlock (int cpu)
 {
 
         if (global_irq_holder == cpu) {
                 global_irq_holder = 0xffffffff;
                 __asm__ __volatile__ ("mf" ::: "memory");
                 clear_bit(0,&global_irq_lock);
         }
 }
 
 static inline void
 local_irq_enter (int irq)
 {
         (((struct cpuinfo_ia64 *) (0xa000000000000000 + 2*(1UL << 14)))->irq_stat.f.irq_count)++;
 
         while (test_bit(0,&global_irq_lock)) {
                              ;
         }
 }
 
 static inline void
 local_irq_exit (int irq)
 {
         (((struct cpuinfo_ia64 *) (0xa000000000000000 + 2*(1UL << 14)))->irq_stat.f.irq_count)--;
 }
 
 static inline int
 local_hardirq_trylock (void)
 {
         return !(((struct cpuinfo_ia64 *) (0xa000000000000000 + 2*(1UL << 14)))->irq_stat.f.irq_count) && !test_bit(0,&global_irq_lock);
 }
 
 
 
 extern void synchronize_irq (void);
 # 48 "/data1/src/linux/include/linux/interrupt.h" 2
 # 1 "/data1/src/linux/include/asm/softirq.h" 1
 # 49 "/data1/src/linux/include/linux/interrupt.h" 2
 # 58 "/data1/src/linux/include/linux/interrupt.h"
 enum
 {
         HI_SOFTIRQ=0,
         NET_TX_SOFTIRQ,
         NET_RX_SOFTIRQ,
         TASKLET_SOFTIRQ
 };
 
 
 
 
 
 struct softirq_action
 {
         void (*action)(struct softirq_action *);
         void *data;
 };
 
  __attribute__((syscall_linkage)) void do_softirq(void);
 extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data);
 extern void softirq_init(void);
 
 extern void cpu_raise_softirq(unsigned int cpu, unsigned int nr);
 extern void raise_softirq(unsigned int nr);
 # 105 "/data1/src/linux/include/linux/interrupt.h"
 struct tasklet_struct
 {
         struct tasklet_struct *next;
         unsigned long state;
         atomic_t count;
         void (*func)(unsigned long);
         unsigned long data;
 };
 # 121 "/data1/src/linux/include/linux/interrupt.h"
 enum
 {
         TASKLET_STATE_SCHED,
         TASKLET_STATE_RUN
 };
 
 struct tasklet_head
 {
         struct tasklet_struct *list;
 } __attribute__ ((__aligned__((1 << (6)))));
 
 extern struct tasklet_head tasklet_vec[32];
 extern struct tasklet_head tasklet_hi_vec[32];
 
 
 static inline int tasklet_trylock(struct tasklet_struct *t)
 {
         return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
 }
 
 static inline void tasklet_unlock(struct tasklet_struct *t)
 {
         __asm__ __volatile__ ("mf" ::: "memory");
         clear_bit(TASKLET_STATE_RUN, &(t)->state);
 }
 
 static inline void tasklet_unlock_wait(struct tasklet_struct *t)
 {
         while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { __asm__ __volatile__("": : :"memory"); }
 }
 
 
 
 
 
 
 extern void __tasklet_schedule(struct tasklet_struct *t);
 
 static inline void tasklet_schedule(struct tasklet_struct *t)
 {
         if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
                 __tasklet_schedule(t);
 }
 
 extern void __tasklet_hi_schedule(struct tasklet_struct *t);
 
 static inline void tasklet_hi_schedule(struct tasklet_struct *t)
 {
         if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
                 __tasklet_hi_schedule(t);
 }
 
 
 static inline void tasklet_disable_nosync(struct tasklet_struct *t)
 {
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&t->count)))->counter)) *_v = (&(((&t->count)))->coun ter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r "(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8 ) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&(((&t->!
 count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: __ba d_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd 8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_t mp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ switch !
 (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); brea k; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatil e__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1] ,%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; de!
 fault: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&t->count)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&t->count))));
         __asm__ __volatile__("": : :"memory");
 }
 
 static inline void tasklet_disable(struct tasklet_struct *t)
 {
         tasklet_disable_nosync(t);
         tasklet_unlock_wait(t);
         __asm__ __volatile__ ("mf" ::: "memory");
 }
 
 static inline void tasklet_enable(struct tasklet_struct *t)
 {
         __asm__ __volatile__("": : :"memory");
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&t->count)))->counter)) *_v = (&(((&t->count)))->coun ter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" :  "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i" (-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&(((&!
 t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: _ _bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetch add8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r" (_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ swit!
 ch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); b reak; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __vola tile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[ %1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break;!
  default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&t->count)))->counter)) (_tmp + (-((1)))); }) : ia64_atomic_sub((1), ((&t->count))));
 }
 
 static inline void tasklet_hi_enable(struct tasklet_struct *t)
 {
         __asm__ __volatile__("": : :"memory");
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&t->count)))->counter)) *_v = (&(((&t->count)))->coun ter); switch (-((1))) { case -16: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" :  "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i" (-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -4: ({ switch (sizeof(*(&(((&!
 t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; default: _ _bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; case 8: __asm__ __volatile__ ("fetch add8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r" (_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 4: ({ swit!
 ch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); b reak; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __vola tile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&t->count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[ %1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break;!
  default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&t->count)))->counter)) (_tmp + (-((1)))); }) : ia64_atomic_sub((1), ((&t->count))));
 }
 
 extern void tasklet_kill(struct tasklet_struct *t);
 extern void tasklet_init(struct tasklet_struct *t,
                          void (*func)(unsigned long), unsigned long data);
 # 224 "/data1/src/linux/include/linux/interrupt.h"
 extern struct tasklet_struct bh_task_vec[];
 
 
 extern spinlock_t global_bh_lock;
 
 static inline void mark_bh(int nr)
 {
         tasklet_hi_schedule(bh_task_vec+nr);
 }
 
 extern void init_bh(int nr, void (*routine)(void));
 extern void remove_bh(int nr);
 # 265 "/data1/src/linux/include/linux/interrupt.h"
 extern unsigned long probe_irq_on(void);
 extern int probe_irq_off(unsigned long);
 extern unsigned int probe_irq_mask(unsigned long);
 # 7 "/data1/src/linux/include/asm/smplock.h" 2
 
 
 
 
 
 
 extern spinlock_t kernel_flag;
 
 
 
 
 
 
 static __inline__ void
 release_kernel_lock(struct task_struct *task, int cpu)
 {
         if (__builtin_expect((task->lock_depth >= 0),0)) {
                 do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &kernel_flag)->lock = 0; } while (0);
                 release_irqlock(cpu);
                 __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory");
         }
 }
 
 
 
 
 static __inline__ void
 reacquire_kernel_lock(struct task_struct *task)
 {
         if (__builtin_expect((task->lock_depth >= 0),0))
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&kernel_flag)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
 }
 # 47 "/data1/src/linux/include/asm/smplock.h"
 static __inline__ void
 lock_kernel(void)
 {
         if (!++current->lock_depth)
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&kernel_flag)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
 }
 
 static __inline__ void
 unlock_kernel(void)
 {
         if (--current->lock_depth < 0)
                 do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &kernel_flag)->lock = 0; } while (0);
 }
 # 17 "/data1/src/linux/include/linux/smp_lock.h" 2
 # 20 "kernel/sched.c" 2
 # 28 "kernel/sched.c"
 typedef struct runqueue runqueue_t;
 
 struct prio_array {
         int nr_active;
         spinlock_t *lock;
         runqueue_t *rq;
         char bitmap[(((128 +40)+7)/8)];
         list_t queue[(128 +40)];
 };
 # 49 "kernel/sched.c"
 static struct runqueue {
         int cpu;
         spinlock_t lock;
         unsigned long nr_running, nr_switches;
         task_t *curr, *idle;
         prio_array_t *active, *expired, arrays[2];
         char __pad [(1 << (6))];
 } runqueues [32] __attribute__((__aligned__((1 << (6))), __section__(".data.cacheline_aligned")));
 # 81 "kernel/sched.c"
 static inline void dequeue_task(struct task_struct *p, prio_array_t *array)
 {
         array->nr_active--;
         list_del_init(&p->run_list);
         if (list_empty(array->queue + p->prio))
                 __set_bit(p->prio, array->bitmap);
 }
 
 static inline void enqueue_task(struct task_struct *p, prio_array_t *array)
 {
         list_add_tail(&p->run_list, array->queue + p->prio);
         __clear_bit(p->prio, array->bitmap);
         array->nr_active++;
         p->array = array;
 }
 
 static inline void activate_task(task_t *p, runqueue_t *rq)
 {
         prio_array_t *array = rq->active;
 
         if (!((p)->policy != 0)) {
                 unsigned long prio_bonus = (((jiffies - p->sleep_jtime) * 20) / 1024);
 
                 if (prio_bonus > (128 +40))
                         prio_bonus = (128 +40);
                 p->prio -= prio_bonus;
                 if (p->prio < 128)
                         p->prio = 128;
         }
         enqueue_task(p, array);
         rq->nr_running++;
 }
 
 static inline void deactivate_task(struct task_struct *p, runqueue_t *rq)
 {
         rq->nr_running--;
         dequeue_task(p, p->array);
         p->array = ((void *)0);
         p->sleep_jtime = jiffies;
 }
 
 static inline void resched_task(task_t *p)
 {
         int need_resched;
 
         need_resched = p->need_resched;
         __asm__ __volatile__ ("mf" ::: "memory");
         p->need_resched = 1;
         if (!need_resched)
                 smp_send_reschedule(p->cpu);
 }
 
 
 
 
 
 
 
 void wait_task_inactive(task_t * p)
 {
         unsigned long flags;
         runqueue_t *rq;
 
 repeat:
         rq = (runqueues + (p)->cpu);
         while (__builtin_expect((rq->curr == p),0)) {
                 do { } while (0);
                 __asm__ __volatile__("": : :"memory");
         }
         do { repeat_lock_task: rq = (runqueues + (p)->cpu); do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq  p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); if (__builtin_ expect(((rq)->cpu != (p)->cpu),0)) { do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0); goto repeat_lock_task; } }  while (0);
         if (__builtin_expect((rq->curr == p),0)) {
                 do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
                 goto repeat;
         }
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 }
 # 167 "kernel/sched.c"
 void kick_if_running(task_t * p)
 {
         if (p == (runqueues + (p)->cpu)->curr)
                 resched_task(p);
 }
 # 182 "kernel/sched.c"
 static int try_to_wake_up(task_t * p, int synchronous)
 {
         unsigned long flags;
         int success = 0;
         runqueue_t *rq;
 
         do { repeat_lock_task: rq = (runqueues + (p)->cpu); do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq  p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); if (__builtin_ expect(((rq)->cpu != (p)->cpu),0)) { do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0); goto repeat_lock_task; } }  while (0);
         p->state = 0;
         if (!p->array) {
                 if (!((p)->policy != 0) && synchronous && ((current->cpu) < p->cpu)) {
                         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\ n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&(runqueues + (current->cpu))->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
                         p->cpu = (current->cpu);
                         activate_task(p, (runqueues + (current->cpu)));
                         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &(runqueues + (current->cpu))->lock)->lock = 0; } while (0);
                 } else {
                         activate_task(p, rq);
                         if ((rq->curr == rq->idle) ||
                                         (p->prio < rq->curr->prio))
                                 resched_task(rq->curr);
                 }
                 success = 1;
         }
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
         return success;
 }
 
 inline int wake_up_process(task_t * p)
 {
         return try_to_wake_up(p, 0);
 }
 
 void wake_up_forked_process(task_t * p)
 {
         runqueue_t *rq = (runqueues + (current->cpu));
 
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
         p->state = 0;
         if (!((p)->policy != 0)) {
                 p->prio += ((((128 +40))-128))/10;
                 if (p->prio > (128 +40)-1)
                         p->prio = (128 +40)-1;
         }
         activate_task(p, rq);
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 }
 
  __attribute__((syscall_linkage)) void schedule_tail(task_t *prev)
 {
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &(runqueues + (current->cpu))->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 }
 
 static inline void context_switch(task_t *prev, task_t *next, int dont_clear)
 {
         struct mm_struct *mm = next->mm;
         struct mm_struct *oldmm = prev->active_mm;
 
         do { } while(0);
 
         if (!mm) {
                 next->active_mm = oldmm;
                 ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&oldmm->mm_count)))->counter)) *_v = (&(((&ol dmm->mm_count)))->counter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fe tchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1 ],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; c!
 ase -4: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v) , "i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory "); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: _ _asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_!
 for_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8. rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&oldmm->mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r "(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&oldmm-> mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "!
 memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&oldmm->mm_count)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&oldmm->mm_count))) );
                 enter_lazy_tlb(oldmm, next, (current->cpu));
         } else
                 activate_mm(oldmm, mm);
 
         if (!prev->mm) {
                 if (!dont_clear)
                         prev->active_mm = ((void *)0);
                 mmdrop(oldmm);
         }
 # 263 "kernel/sched.c"
         do { if (((struct ia64_psr *) &((((struct pt_regs *) ((char *) (prev) + ((1 << 1)*(1UL << 14)))) - 1))->cr_ipsr)->mfh) { ((struct ia64_psr *) &((((struct pt_regs *) ((char *) (prev) + ((1 << 1)*(1UL << 14)))) - 1))->cr_ipsr)->mfh = 0; (prev)->thr ead.flags |= (((unsigned long)(1)) << 0); __ia64_save_fpu((prev)->thread.fph); } ((struct ia64_psr *) &((((struct pt_regs *) ((char *) (prev) + ((1 << 1)*(1UL << 14)))) - 1))->cr_ipsr)->dfh = 1; do { if (((prev)->thread.flags & ((((unsigned long)(1)) <<  1)|(((unsigned long)(1)) << 2))) || (((struct ia64_psr *) &((((struct pt_regs *) ((char *) (prev) + ((1 << 1)*(1UL << 14)))) - 1))->cr_ipsr)->is != 0)) ia64_save_extra(prev); if (((next)->thread.flags & ((((unsigned long)(1)) << 1)|(((unsigned long)(1))  << 2))) || (((struct ia64_psr *) &((((struct pt_regs *) ((char *) (next) + ((1 << 1)*(1UL << 14)))) - 1))->cr_ipsr)->is != 0)) ia64_load_extra(next); (prev) = ia64_switch_to((next)); } while (0); } while (0);
 }
 
 unsigned long nr_running(void)
 {
         unsigned long i, sum = 0;
 
         for (i = 0; i < smp_num_cpus; i++)
                 sum += (runqueues + (i))->nr_running;
 
         return sum;
 }
 
 unsigned long nr_context_switches(void)
 {
         unsigned long i, sum = 0;
 
         for (i = 0; i < smp_num_cpus; i++)
                 sum += (runqueues + (i))->nr_switches;
 
         return sum;
 }
 
 static inline unsigned long max_rq_len(void)
 {
         unsigned long i, curr, max = 0;
 
         for (i = 0; i < smp_num_cpus; i++) {
                 curr = (runqueues + (i))->nr_running;
                 if (curr > max)
                         max = curr;
         }
         return max;
 }
 # 305 "kernel/sched.c"
 static void load_balance(runqueue_t *this_rq)
 {
         int nr_tasks, load, prev_max_load, max_load, idx, i;
         task_t *next = this_rq->idle, *tmp;
         runqueue_t *busiest, *rq_tmp;
         prio_array_t *array;
         list_t *head, *curr;
 
         prev_max_load = max_rq_len();
         nr_tasks = prev_max_load - this_rq->nr_running;
 
 
 
         if (nr_tasks <= 1 + prev_max_load/8)
                 return;
         prev_max_load++;
 
 repeat_search:
 
 
 
 
 
         busiest = ((void *)0);
         max_load = 0;
         for (i = 0; i < smp_num_cpus; i++) {
                 rq_tmp = (runqueues + (i));
                 load = rq_tmp->nr_running;
                 if ((load > max_load) && (load < prev_max_load) &&
                                                 (rq_tmp != this_rq)) {
                         busiest = rq_tmp;
                         max_load = load;
                 }
         }
 
         if (__builtin_expect((!busiest),1))
                 return;
         if (max_load <= this_rq->nr_running)
                 return;
         prev_max_load = max_load;
         if (busiest->cpu < this_rq->cpu) {
                 do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &this_rq->lock)->lock = 0; } while (0);
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&busiest->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&this_rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         } else
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&busiest->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         if (busiest->nr_running <= this_rq->nr_running + 1)
                 goto out_unlock;
 
 
 
 
 
 
         if (busiest->expired->nr_active)
                 array = busiest->expired;
         else
                 array = busiest->active;
 
 new_array:
 
 
 
 
         idx = 128;
 skip_bitmap:
         idx = find_next_zero_bit(array->bitmap, (128 +40), idx);
         if (idx == (128 +40)) {
                 if (array == busiest->expired) {
                         array = busiest->active;
                         goto new_array;
                 }
                 do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &busiest->lock)->lock = 0; } while (0);
                 goto repeat_search;
         }
 
         head = array->queue + idx;
         curr = head->next;
 skip_queue:
         tmp = ((task_t *)((char *)(curr)-(unsigned long)(&((task_t *)0)->run_list)));
         if ((tmp == busiest->curr) || !(tmp->cpus_allowed & (1 << (current->cpu)))) {
                 curr = curr->next;
                 if (curr != head)
                         goto skip_queue;
                 idx++;
                 goto skip_bitmap;
         }
         next = tmp;
 
 
 
 
         dequeue_task(next, array);
         busiest->nr_running--;
         next->cpu = (current->cpu);
         this_rq->nr_running++;
         enqueue_task(next, this_rq->active);
         if (next->prio < current->prio)
                 current->need_resched = 1;
         if (--nr_tasks) {
                 if (array == busiest->expired) {
                         array = busiest->active;
                         goto new_array;
                 }
                 do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &busiest->lock)->lock = 0; } while (0);
                 goto repeat_search;
         }
 out_unlock:
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &busiest->lock)->lock = 0; } while (0);
 }
 
 
 
 
 void idle_tick(void)
 {
         unsigned long flags;
 
         if (!(jiffies % (1024/4)) && __builtin_expect(((runqueues + (current->cpu))->curr != ((void *)0)),1)) {
                 do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b  \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&(runqueues + (current->cpu))->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 load_balance((runqueues + (current->cpu)));
                 do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &(runqueues + (current->cpu))->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
         }
 }
 
 void expire_task(task_t *p)
 {
         runqueue_t *rq = (runqueues + (current->cpu));
         unsigned long flags;
 
         if (p->array != rq->active) {
                 p->need_resched = 1;
                 return;
         }
 
 
 
         do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmp xchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
         if ((p->policy != 1) && !--p->time_slice) {
                 unsigned int time_slice;
                 p->need_resched = 1;
                 dequeue_task(p, rq->active);
                 time_slice = ((( (128 -(p->prio)-1)*((150 * 1024 / 1000)-( 20 * 1024 / 1000)) + 128 -1) / 128) + ( 20 * 1024 / 1000));
                 if (!((p)->policy != 0)) {
                         time_slice = ((( (((((128 +40))-128))-1-((p->prio)-128))*((150 * 1024 / 1000)-( 20 * 1024 / 1000)) + ((((128 +40))-128))-1) / ((((128 +40))-128))) + ( 20 * 1024 / 1000));
                         if (++p->prio >= (128 +40))
                                 p->prio = (128 +40) - 1;
                 }
                 p->time_slice = time_slice;
                 if (((p)->prio >= 128 && (p)->prio <= (128 + ((128 +40) - 128) / 4)))
                         enqueue_task(p, rq->active);
                 else
                         enqueue_task(p, rq->expired);
         }
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 }
 
 void scheduling_functions_start_here(void) { }
 
 
 
 
  __attribute__((syscall_linkage)) void schedule(void)
 {
         task_t *prev, *next;
         prio_array_t *array;
         runqueue_t *rq;
         list_t *queue;
         int idx;
 
         if (__builtin_expect(((((struct cpuinfo_ia64 *) (0xa000000000000000 + 2*(1UL << 14)))->irq_stat.irq_and_bh_counts != 0)),0))
                 do { printk("kernel BUG at %s:%d!\n", "kernel/sched.c", 476); *(int *)0=0; } while (0);
 need_resched_back:
         prev = current;
         release_kernel_lock(prev, (current->cpu));
         rq = (runqueues + (current->cpu));
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
 
         switch (prev->state) {
         case 1:
                 if (__builtin_expect((signal_pending(prev)),0)) {
                         prev->state = 0;
                         break;
                 }
         default:
                 deactivate_task(prev, rq);
         case 0:
         }
 pick_next_task:
         if (__builtin_expect((!rq->nr_running),0)) {
                 load_balance(rq);
                 if (rq->nr_running)
                         goto pick_next_task;
                 next = rq->idle;
                 goto switch_tasks;
         }
 
         array = rq->active;
         if (__builtin_expect((!array->nr_active),0)) {
 
 
 
                 rq->active = rq->expired;
                 rq->expired = array;
                 array = rq->active;
         }
 
         idx = sched_find_first_zero_bit(array->bitmap);
         queue = array->queue + idx;
         next = ((task_t *)((char *)(queue->next)-(unsigned long)(&((task_t *)0)->run_list)));
 
 switch_tasks:
         prev->need_resched = 0;
 
         if (__builtin_expect((prev != next),1)) {
                 rq->nr_switches++;
                 rq->curr = next;
                 next->cpu = prev->cpu;
                 context_switch(prev, next, 0);
 
 
 
 
 
                 __asm__ __volatile__("": : :"memory");
                 rq = (runqueues + (current->cpu));
         }
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 
         reacquire_kernel_lock(current);
         if (__builtin_expect((current->need_resched),0))
                 goto need_resched_back;
         return;
 }
 # 549 "kernel/sched.c"
 static inline void __wake_up_common (wait_queue_head_t *q, unsigned int mode,
                                      int nr_exclusive, const int sync)
 {
         struct list_head *tmp;
         task_t *p;
 
         for (tmp = (&q->task_list)->next, prefetch(tmp->next); tmp != (&q->task_list); tmp = tmp->next, prefetch(tmp->next)) {
                 unsigned int state;
                 wait_queue_t *curr = ((wait_queue_t *)((char *)(tmp)-(unsigned long)(&((wait_queue_t *)0)->task_list)));
 
                 p = curr->task;
                 state = p->state;
                 if ((state & mode) &&
                                 try_to_wake_up(p, sync) &&
                                 ((curr->flags & 0x01) &&
                                         !--nr_exclusive))
                         break;
         }
 }
 
 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr)
 {
         if (q) {
                 unsigned long flags;
                 do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b  \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 __wake_up_common(q, mode, nr, 0);
                 do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &q->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
         }
 }
 
 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr)
 {
         if (q) {
                 unsigned long flags;
                 do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b  \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 __wake_up_common(q, mode, nr, 1);
                 do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &q->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
         }
 }
 
 void complete(struct completion *x)
 {
         unsigned long flags;
 
         do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmp xchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&x->wait.lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
         x->done++;
         __wake_up_common(&x->wait, 2 | 1, 1, 0);
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &x->wait.lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 }
 
 void wait_for_completion(struct completion *x)
 {
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&x->wait.lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
         if (!x->done) {
                 wait_queue_t wait = { task: current, task_list: { ((void *)0), ((void *)0) } };
 
                 wait.flags |= 0x01;
                 __add_wait_queue_tail(&x->wait, &wait);
                 do {
                         do { current->state = (2); } while (0);
                         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &x->wait.lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
                         schedule();
                         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.ac q r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&x->wait.lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 } while (!x->done);
                 __remove_wait_queue(&x->wait, &wait);
         }
         x->done--;
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &x->wait.lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 }
 # 634 "kernel/sched.c"
 void interruptible_sleep_on(wait_queue_head_t *q)
 {
         unsigned long flags; wait_queue_t wait; init_waitqueue_entry(&wait, current);
 
         current->state = 1;
 
         do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmp xchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __add_wait_queue(q, &wait); do { __asm__ __volatile__("": : :"memor y"); ((spinlock_t *) &q->lock)->lock = 0; } while (0);
         schedule();
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __remove_wait_queue(q, &wait); do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_ t *) &q->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 }
 
 long interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
 {
         unsigned long flags; wait_queue_t wait; init_waitqueue_entry(&wait, current);
 
         current->state = 1;
 
         do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmp xchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __add_wait_queue(q, &wait); do { __asm__ __volatile__("": : :"memor y"); ((spinlock_t *) &q->lock)->lock = 0; } while (0);
         timeout = schedule_timeout(timeout);
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __remove_wait_queue(q, &wait); do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_ t *) &q->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 
         return timeout;
 }
 
 void sleep_on(wait_queue_head_t *q)
 {
         unsigned long flags; wait_queue_t wait; init_waitqueue_entry(&wait, current);
 
         current->state = 2;
 
         do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmp xchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __add_wait_queue(q, &wait); do { __asm__ __volatile__("": : :"memor y"); ((spinlock_t *) &q->lock)->lock = 0; } while (0);
         schedule();
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __remove_wait_queue(q, &wait); do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_ t *) &q->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 }
 
 long sleep_on_timeout(wait_queue_head_t *q, long timeout)
 {
         unsigned long flags; wait_queue_t wait; init_waitqueue_entry(&wait, current);
 
         current->state = 2;
 
         do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmp xchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __add_wait_queue(q, &wait); do { __asm__ __volatile__("": : :"memor y"); ((spinlock_t *) &q->lock)->lock = 0; } while (0);
         timeout = schedule_timeout(timeout);
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&q->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); __remove_wait_queue(q, &wait); do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_ t *) &q->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 
         return timeout;
 }
 
 
 
 
 
 
 void set_cpus_allowed(task_t *p, unsigned long new_mask)
 {
         runqueue_t *this_rq = (runqueues + (current->cpu)), *target_rq;
         unsigned long this_mask = 1UL << (current->cpu);
         int target_cpu;
 
         new_mask &= cpu_online_map;
         p->cpus_allowed = new_mask;
 
 
 
 
         if (new_mask & this_mask)
                 return;
         target_cpu = ffz(~new_mask);
         target_rq = (runqueues + (target_cpu));
         if (target_cpu < (current->cpu)) {
                 do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [ %0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&target_rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&this_rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         } else {
                 do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [ %0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&target_rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&this_rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         }
         dequeue_task(p, p->array);
         this_rq->nr_running--;
         target_rq->nr_running++;
         enqueue_task(p, target_rq->active);
         target_rq->curr->need_resched = 1;
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &target_rq->lock)->lock = 0; } while (0);
 
 
 
 
 
 
         this_rq->nr_switches++;
         this_rq->curr = this_rq->idle;
         this_rq->idle->need_resched = 1;
         context_switch(current, this_rq->idle, 1);
         __asm__ __volatile__("": : :"memory");
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &(runqueues + (current->cpu))->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 }
 
 void scheduling_functions_end_here(void) { }
 
 void set_user_nice(task_t *p, long nice)
 {
         unsigned long flags;
         prio_array_t *array;
         runqueue_t *rq;
 
         if (p->__nice == nice)
                 return;
 
 
 
 
         do { repeat_lock_task: rq = (runqueues + (p)->cpu); do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq  p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); if (__builtin_ expect(((rq)->cpu != (p)->cpu),0)) { do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0); goto repeat_lock_task; } }  while (0);
         if (((p)->policy != 0)) {
                 p->__nice = nice;
                 goto out_unlock;
         }
         array = p->array;
         if (array) {
                 dequeue_task(p, array);
         }
         p->__nice = nice;
         p->prio = ((128 +40)-1 + (nice) - 19);
         if (array) {
                 enqueue_task(p, array);
 
 
 
 
                 if ((nice < p->__nice) ||
                                 ((p->__nice < nice) && (p == rq->curr)))
                         resched_task(rq->curr);
         }
 out_unlock:
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 }
 # 777 "kernel/sched.c"
  __attribute__((syscall_linkage)) long sys_nice(int increment)
 {
         long nice;
 
 
 
 
 
 
         if (increment < 0) {
                 if (!capable(23))
                         return -1;
                 if (increment < -40)
                         increment = -40;
         }
         if (increment > 40)
                 increment = 40;
 
         nice = current->__nice + increment;
         if (nice < -20)
                 nice = -20;
         if (nice > 19)
                 nice = 19;
         set_user_nice(current, nice);
         return 0;
 }
 
 
 
 static inline task_t *find_process_by_pid(pid_t pid)
 {
         return pid ? find_task_by_pid(pid) : current;
 }
 
 static int setscheduler(pid_t pid, int policy, struct sched_param *param)
 {
         struct sched_param lp;
         prio_array_t *array;
         unsigned long flags;
         runqueue_t *rq;
         int retval;
         task_t *p;
 
         retval = -22;
         if (!param || pid < 0)
                 goto out_nounlock;
 
         retval = -14;
         if (({ void *__cu_to = ((&lp)); const void *__cu_from = ((param)); long __cu_len = ((sizeof(struct sched_param))); if ((((unsigned long) ((long) ((0) ? __cu_to : __cu_from))) <= ((current->addr_limit)).seg && (((current->addr_limit)).seg == ((mm_ segment_t) { ~0UL }).seg || rgn_offset((unsigned long) ((long) ((0) ? __cu_to : __cu_from))) < ((1UL << (4*14 - 12)) - (1UL << 14))))) { __cu_len = __copy_user(__cu_to, __cu_from, __cu_len); } __cu_len; }))
                 goto out_nounlock;
 
 
 
 
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); do { int tmp = 0; __asm__ __volatile__ ("1:\tfetchadd4.acq %0 = [%1], 1\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 2f\n" ".section .text.lock,\"ax\"\n" "2:\tfetchadd4.rel  %0 = [%1], -1\n" ";;\n" "3:\tld4.acq %0 = [%1]\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 3b\n" "br.cond.sptk.few 1b\n" ";;\n" ".previous\n" : "=&r" (tmp) : "r" (&tasklist_lock) : "p6", "memory"); } while(0); } while (0);
 
         p = find_process_by_pid(pid);
 
         retval = -3;
         if (!p)
                 goto out_unlock_tasklist;
 
 
 
 
 
         do { repeat_lock_task: rq = (runqueues + (p)->cpu); do { __asm__ __volatile__ ("mov %0=psr;; rsm psr.i;;" : "=r" (flags) :: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq  p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0); if (__builtin_ expect(((rq)->cpu != (p)->cpu),0)) { do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0); goto repeat_lock_task; } }  while (0);
 
         if (policy < 0)
                 policy = p->policy;
         else {
                 retval = -22;
                 if (policy != 1 && policy != 2 &&
                                 policy != 0)
                         goto out_unlock;
         }
 
 
 
 
 
         retval = -22;
         if (lp.sched_priority < 0 || lp.sched_priority > 99)
                 goto out_unlock;
         if ((policy == 0) != (lp.sched_priority == 0))
                 goto out_unlock;
 
         retval = -1;
         if ((policy == 1 || policy == 2) &&
             !capable(23))
                 goto out_unlock;
         if ((current->euid != p->euid) && (current->euid != p->uid) &&
             !capable(23))
                 goto out_unlock;
 
         array = p->array;
         if (array)
                 deactivate_task(p, (runqueues + (p)->cpu));
         retval = 0;
         p->policy = policy;
         p->rt_priority = lp.sched_priority;
         if (((p)->policy != 0))
                 p->prio = 99-p->rt_priority;
         else
                 p->prio = ((128 +40)-1 + (p->__nice) - 19);
         if (array)
                 activate_task(p, (runqueues + (p)->cpu));
 
 out_unlock:
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; mov psr.l=%0;; srlz.d" :: "r" (flags) : "memory"); } while (0);
 out_unlock_tasklist:
         do { do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&tasklist_lock) : "memory"); } while(0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 
 out_nounlock:
         return retval;
 }
 
  __attribute__((syscall_linkage)) long sys_sched_setscheduler(pid_t pid, int policy,
                                       struct sched_param *param)
 {
         return setscheduler(pid, policy, param);
 }
 
  __attribute__((syscall_linkage)) long sys_sched_setparam(pid_t pid, struct sched_param *param)
 {
         return setscheduler(pid, -1, param);
 }
 
  __attribute__((syscall_linkage)) long sys_sched_getscheduler(pid_t pid)
 {
         task_t *p;
         int retval;
 
         retval = -22;
         if (pid < 0)
                 goto out_nounlock;
 
         retval = -3;
         do { int tmp = 0; __asm__ __volatile__ ("1:\tfetchadd4.acq %0 = [%1], 1\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 2f\n" ".section .text.lock,\"ax\"\n" "2:\tfetchadd4.rel %0 = [%1], -1\n" ";;\n" "3:\tld4.acq %0 = [%1]\n" ";;\n" " tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 3b\n" "br.cond.sptk.few 1b\n" ";;\n" ".previous\n" : "=&r" (tmp) : "r" (&tasklist_lock) : "p6", "memory"); } while(0);
         p = find_process_by_pid(pid);
         if (p)
                 retval = p->policy;
         do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&tasklist_lock) : "memory"); } while(0);
 
 out_nounlock:
         return retval;
 }
 
  __attribute__((syscall_linkage)) long sys_sched_getparam(pid_t pid, struct sched_param *param)
 {
         task_t *p;
         struct sched_param lp;
         int retval;
 
         retval = -22;
         if (!param || pid < 0)
                 goto out_nounlock;
 
         do { int tmp = 0; __asm__ __volatile__ ("1:\tfetchadd4.acq %0 = [%1], 1\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 2f\n" ".section .text.lock,\"ax\"\n" "2:\tfetchadd4.rel %0 = [%1], -1\n" ";;\n" "3:\tld4.acq %0 = [%1]\n" ";;\n" " tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 3b\n" "br.cond.sptk.few 1b\n" ";;\n" ".previous\n" : "=&r" (tmp) : "r" (&tasklist_lock) : "p6", "memory"); } while(0);
         p = find_process_by_pid(pid);
         retval = -3;
         if (!p)
                 goto out_unlock;
         lp.sched_priority = p->rt_priority;
         do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&tasklist_lock) : "memory"); } while(0);
 
 
 
 
         retval = ({ void *__cu_to = ((param)); const void *__cu_from = ((&lp)); long __cu_len = ((sizeof(*param))); if ((((unsigned long) ((long) ((1) ? __cu_to : __cu_from))) <= ((current->addr_limit)).seg && (((current->addr_limit)).seg == ((mm_segment _t) { ~0UL }).seg || rgn_offset((unsigned long) ((long) ((1) ? __cu_to : __cu_from))) < ((1UL << (4*14 - 12)) - (1UL << 14))))) { __cu_len = __copy_user(__cu_to, __cu_from, __cu_len); } __cu_len; }) ? -14 : 0;
 
 out_nounlock:
         return retval;
 
 out_unlock:
         do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&tasklist_lock) : "memory"); } while(0);
         return retval;
 }
 
  __attribute__((syscall_linkage)) long sys_sched_yield(void)
 {
         runqueue_t *rq = (runqueues + (current->cpu));
         prio_array_t *array;
 # 969 "kernel/sched.c"
         do { __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory"); __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29 , ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory"); } while (0);
         array = current->array;
         dequeue_task(current, array);
         if (__builtin_expect((!((current)->policy != 0)),1))
                 if (current->prio < (128 +40)-1)
                         current->prio++;
         enqueue_task(current, array);
         do { do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq->lock)->lock = 0; } while (0); __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory"); } while (0);
 
         schedule();
 
         return 0;
 }
 
  __attribute__((syscall_linkage)) long sys_sched_get_priority_max(int policy)
 {
         int ret = -22;
 
         switch (policy) {
         case 1:
         case 2:
                 ret = 99;
                 break;
         case 0:
                 ret = 0;
                 break;
         }
         return ret;
 }
 
  __attribute__((syscall_linkage)) long sys_sched_get_priority_min(int policy)
 {
         int ret = -22;
 
         switch (policy) {
         case 1:
         case 2:
                 ret = 1;
                 break;
         case 0:
                 ret = 0;
         }
         return ret;
 }
 
  __attribute__((syscall_linkage)) long sys_sched_rr_get_interval(pid_t pid, struct timespec *interval)
 {
         struct timespec t;
         task_t *p;
         int retval = -22;
 
         if (pid < 0)
                 goto out_nounlock;
 
         retval = -3;
         do { int tmp = 0; __asm__ __volatile__ ("1:\tfetchadd4.acq %0 = [%1], 1\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 2f\n" ".section .text.lock,\"ax\"\n" "2:\tfetchadd4.rel %0 = [%1], -1\n" ";;\n" "3:\tld4.acq %0 = [%1]\n" ";;\n" " tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 3b\n" "br.cond.sptk.few 1b\n" ";;\n" ".previous\n" : "=&r" (tmp) : "r" (&tasklist_lock) : "p6", "memory"); } while(0);
         p = find_process_by_pid(pid);
         if (p)
                 jiffies_to_timespec(p->policy & 1 ?
                                          0 : ((( (128 -(p->prio)-1)*((150 * 1024 / 1000)-( 20 * 1024 / 1000)) + 128 -1) / 128) + ( 20 * 1024 / 1000)), &t);
         do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&tasklist_lock) : "memory"); } while(0);
         if (p)
                 retval = ({ void *__cu_to = ((interval)); const void *__cu_from = ((&t)); long __cu_len = ((sizeof(t))); if ((((unsigned long) ((long) ((1) ? __cu_to : __cu_from))) <= ((current->addr_limit)).seg && (((current->addr_limit)).seg == ((mm_se gment_t) { ~0UL }).seg || rgn_offset((unsigned long) ((long) ((1) ? __cu_to : __cu_from))) < ((1UL << (4*14 - 12)) - (1UL << 14))))) { __cu_len = __copy_user(__cu_to, __cu_from, __cu_len); } __cu_len; }) ? -14 : 0;
 out_nounlock:
         return retval;
 }
 
 static void show_task(task_t * p)
 {
         unsigned long free = 0;
         int state;
         static const char * stat_nam[] = { "R", "S", "D", "Z", "T", "W" };
 
         printk("%-13.13s ", p->comm);
         state = p->state ? ffz(~p->state) + 1 : 0;
         if (((unsigned) state) < sizeof(stat_nam)/sizeof(char *))
                 printk(stat_nam[state]);
         else
                 printk(" ");
 
 
 
 
 
 
         if (p == current)
                 printk("   current task   ");
         else
                 printk(" %016lx ", thread_saved_pc(&p->thread));
 
         {
                 unsigned long * n = (unsigned long *) (p+1);
                 while (!*n)
                         n++;
                 free = (unsigned long) n - (unsigned long)(p+1);
         }
         printk("%5lu %5d %6d ", free, p->pid, p->p_pptr->pid);
         if (p->p_cptr)
                 printk("%5d ", p->p_cptr->pid);
         else
                 printk("      ");
         if (p->p_ysptr)
                 printk("%7d", p->p_ysptr->pid);
         else
                 printk("       ");
         if (p->p_osptr)
                 printk(" %5d", p->p_osptr->pid);
         else
                 printk("      ");
         if (!p->mm)
                 printk(" (L-TLB)\n");
         else
                 printk(" (NOTLB)\n");
 
         {
                 extern void show_trace_task(task_t *tsk);
                 show_trace_task(p);
         }
 }
 
 char * render_sigset_t(sigset_t *set, char *buffer)
 {
         int i = 64, x;
         do {
                 i -= 4, x = 0;
                 if (sigismember(set, i+1)) x |= 1;
                 if (sigismember(set, i+2)) x |= 2;
                 if (sigismember(set, i+3)) x |= 4;
                 if (sigismember(set, i+4)) x |= 8;
                 *buffer++ = (x < 10 ? '0' : 'a' - 10) + x;
         } while (i >= 4);
         *buffer = 0;
         return buffer;
 }
 
 void show_state(void)
 {
         task_t *p;
 
 
 
 
 
 
         printk("\n"
                "                                 free                        sibling\n");
         printk("  task                 PC        stack   pid father child younger older\n");
 
         do { int tmp = 0; __asm__ __volatile__ ("1:\tfetchadd4.acq %0 = [%1], 1\n" ";;\n" "tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 2f\n" ".section .text.lock,\"ax\"\n" "2:\tfetchadd4.rel %0 = [%1], -1\n" ";;\n" "3:\tld4.acq %0 = [%1]\n" ";;\n" " tbit.nz p6,p0 = %0, 31\n" "(p6) br.cond.sptk.few 3b\n" "br.cond.sptk.few 1b\n" ";;\n" ".previous\n" : "=&r" (tmp) : "r" (&tasklist_lock) : "p6", "memory"); } while(0);
         for (p = &(init_task_union.task) ; (p = p->next_task) != &(init_task_union.task) ; ) {
 
 
 
 
                 do { } while(0);
                 show_task(p);
         }
         do { int tmp = 0; __asm__ __volatile__ ("fetchadd4.rel %0 = [%1], -1\n" : "=r" (tmp) : "r" (&tasklist_lock) : "memory"); } while(0);
 }
 
 extern unsigned long wait_init_idle;
 
 static inline void double_rq_lock(runqueue_t *rq1, runqueue_t *rq2)
 {
         if (rq1 == rq2)
                 __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\n" "(p7)  br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq1->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
         else {
                 if (rq1->cpu < rq2->cpu) {
                         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\ n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq1->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
                         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\ n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq2->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
                 } else {
                         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\ n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq2->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
                         __asm__ __volatile__ ( "mov ar.ccv = r0\n" "mov r29 = 1\n" ";;\n" "1:\n" "ld4.bias r2 = [%0]\n" ";;\n" "cmp4.eq p0,p7 = r0,r2\n" "(p7) br.cond.spnt.few 1b \n" "cmpxchg4.acq r2 = [%0], r29, ar.ccv\n" ";;\n" "cmp4.eq p0,p7 = r0, r2\ n" "(p7) br.cond.spnt.few 1b\n" ";;\n" :: "r"(&(&rq1->lock)->lock) : "ar.ccv", "p7", "r2", "r29", "memory");
                 }
         }
 }
 
 static inline void double_rq_unlock(runqueue_t *rq1, runqueue_t *rq2)
 {
         do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq1->lock)->lock = 0; } while (0);
         if (rq1 != rq2)
                 do { __asm__ __volatile__("": : :"memory"); ((spinlock_t *) &rq2->lock)->lock = 0; } while (0);
 }
 
 void __attribute__ ((__section__ (".text.init"))) init_idle(void)
 {
         runqueue_t *this_rq = (runqueues + (current->cpu)), *rq = current->array->rq;
         unsigned long flags;
 
         __asm__ __volatile__ ("mov %0=psr" : "=r" (flags) :: "memory");
         __asm__ __volatile__ (";; rsm psr.i;;" ::: "memory");
         double_rq_lock(this_rq, rq);
 
         this_rq->curr = this_rq->idle = current;
         deactivate_task(current, rq);
         current->array = ((void *)0);
         current->prio = (128 +40);
         current->state = 0;
         clear_bit((current->cpu), &wait_init_idle);
         double_rq_unlock(this_rq, rq);
         while (wait_init_idle) {
                 do { } while (0);
                 __asm__ __volatile__("": : :"memory");
         }
         current->need_resched = 1;
         __asm__ __volatile__ (";; ssm psr.i;; srlz.d" ::: "memory");
 }
 
 extern void init_timervecs(void);
 extern void timer_bh(void);
 extern void tqueue_bh(void);
 extern void immediate_bh(void);
 
 void __attribute__ ((__section__ (".text.init"))) sched_init(void)
 {
         runqueue_t *rq;
         int i, j, k;
 
         for (i = 0; i < 32; i++) {
                 runqueue_t *rq = (runqueues + (i));
                 prio_array_t *array;
 
                 rq->active = rq->arrays + 0;
                 rq->expired = rq->arrays + 1;
                 ((&rq->lock)->lock = 0);
                 rq->cpu = i;
 
                 for (j = 0; j < 2; j++) {
                         array = rq->arrays + j;
                         array->rq = rq;
                         array->lock = &rq->lock;
                         for (k = 0; k < (128 +40); k++)
                                 do { (array->queue + k)->next = (array->queue + k); (array->queue + k)->prev = (array->queue + k); } while (0);
                         memset(array->bitmap, 0xff, (((128 +40)+7)/8));
 
                         clear_bit((128 +40), array->bitmap);
                 }
         }
 
 
 
 
         rq = (runqueues + (current->cpu));
         rq->curr = current;
         rq->idle = ((void *)0);
         wake_up_process(current);
 
         for (i = 0; i < (4096 >> 2); i++)
                 pidhash[i] = ((void *)0);
 
         init_timervecs();
         init_bh(TIMER_BH, timer_bh);
         init_bh(TQUEUE_BH, tqueue_bh);
         init_bh(IMMEDIATE_BH, immediate_bh);
 
 
 
 
         ((__builtin_constant_p((1)) && ( ((1) == 1) || ((1) == 4) || ((1) == 8) || ((1) == 16) || ((1) == -1) || ((1) == -4) || ((1) == -8) || ((1) == -16))) ? ({ __u64 _tmp; volatile __typeof__(*(&(((&init_mm.mm_count)))->counter)) *_v = (&(((&init_mm.m m_count)))->counter); switch ((1)) { case -16: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchad d8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-16) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -8: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2 " : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case !
 -4: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), " i"(-4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case -1: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory") ; break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(-1) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 1: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __ asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(1) : "memory"); break; default: __bad_size_f!
 or_ia64_fetch_and_add(); } }); break; case 4: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8. rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(4) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 8: ({ switch (sizeof(*(&(((&init_mm.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "= r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(8) : "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; case 16: ({ switch (sizeof(*(&(((&init_m m.mm_count)))->counter))) { case 4: __asm__ __volatile__ ("fetchadd4.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) : "memory"); break; case 8: __asm__ __volatile__ ("fetchadd8.rel %0=[%1],%2" : "=r"(_tmp) : "r"(_v), "i"(16) :!
  "memory"); break; default: __bad_size_for_ia64_fetch_and_add(); } }); break; default: _tmp = __bad_increment_for_ia64_fetch_and_add(); break; } (__typeof__(*&(((&init_mm.mm_count)))->counter)) (_tmp + ((1))); }) : ia64_atomic_add((1), ((&init_mm.mm_coun t))));
         enter_lazy_tlb(&init_mm, current, (current->cpu));
 }